diff --git a/community/aqua/general/simulations_with_noise.ipynb b/community/aqua/general/simulations_with_noise.ipynb
new file mode 100644
index 000000000..75d56803e
--- /dev/null
+++ b/community/aqua/general/simulations_with_noise.ipynb
@@ -0,0 +1,308 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## _*Running simulations with noise in Aqua*_\n",
+    "\n",
+    "This notebook demonstrates using the [Qiskit Aer](https://qiskit.org/aer) `qasm_simulator` to run a simulation with noise, based on a noise model, in Aqua. This can be useful to investigate behavior under different noise conditions. Aer not only allows you to define your own custom noise model, but also allows a noise model to be easily created based on the properties of a real quantum device. The latter is what this notebook will demonstrate since the goal is to show how to do this in Aqua not how to build custom noise models.\n",
+    "\n",
+    "Further information on Qiskit Aer noise model can be found in the online Qiskit Aer documentation [here](https://qiskit.org/documentation/aer/device_noise_simulation.html) as well as in the [Qiskit Aer tutorials](https://github.com/Qiskit/qiskit-tutorials/tree/master/qiskit/aer).\n",
+    "\n",
+    "Note: this tutorial requires Qiskit Aer if you intend to run it. This can be installed using pip if you do not have it installed using `pip install qiskit-aer`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pylab\n",
+    "\n",
+    "from qiskit import Aer, IBMQ\n",
+    "from qiskit.aqua import Operator, QuantumInstance, aqua_globals\n",
+    "from qiskit.aqua.algorithms.adaptive import VQE\n",
+    "from qiskit.aqua.algorithms.classical import ExactEigensolver\n",
+    "from qiskit.aqua.components.optimizers import SPSA\n",
+    "from qiskit.aqua.components.variational_forms import RY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Noisy simulation will be demonstrated here with VQE, finding the minimum (ground state) energy of an Hamiltonian, but the technique applies to any quantum algorithm from Aqua.\n",
+    "\n",
+    "So for VQE we need a qubit operator as input. Here we will take a set of paulis that were originally computed by qiskit-chemistry, for an H2 molecule, so we can quickly create an Operator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of qubits: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "pauli_dict = {\n",
+    "    'paulis': [{\"coeff\": {\"imag\": 0.0, \"real\": -1.052373245772859}, \"label\": \"II\"},\n",
+    "              {\"coeff\": {\"imag\": 0.0, \"real\": 0.39793742484318045}, \"label\": \"ZI\"},\n",
+    "              {\"coeff\": {\"imag\": 0.0, \"real\": -0.39793742484318045}, \"label\": \"IZ\"},\n",
+    "              {\"coeff\": {\"imag\": 0.0, \"real\": -0.01128010425623538}, \"label\": \"ZZ\"},\n",
+    "              {\"coeff\": {\"imag\": 0.0, \"real\": 0.18093119978423156}, \"label\": \"XX\"}\n",
+    "              ]\n",
+    "}\n",
+    "\n",
+    "qubit_op = Operator.load_from_dict(pauli_dict)\n",
+    "num_qubits = qubit_op.num_qubits\n",
+    "print('Number of qubits: {}'.format(num_qubits))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As the above problem is still easily tractable classically we can use ExactEigensolver to compute a reference value so we can compare later the results. \n",
+    "\n",
+    "<span style=\"font-size:0.9em\">_(A copy of the operator is used below as what is passed to ExactEigensolver will be converted to matrix form and we want the operator we use later, on the Aer qasm simuator, to be in paulis form.)_</span>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reference value: -1.85727503020238\n"
+     ]
+    }
+   ],
+   "source": [
+    "ee = ExactEigensolver(qubit_op.copy())\n",
+    "result = ee.run()\n",
+    "ref = result['energy']\n",
+    "print('Reference value: {}'.format(ref))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Performance *without* noise\n",
+    "\n",
+    "First we will run on the simulator without adding noise to see the result. I have created the backend and QuantumInstance, which holds the backend as well as various other run time configuration, which are defaulted here, so it easy to compare when we get to the next section where noise is added. There is no attempt to mitigate noise or anything in this notebook so the latter setup and running of VQE is identical."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VQE on Aer qasm simulator (no noise): -1.8662346923695476\n",
+      "Delta from reference: -0.008959662167167703\n"
+     ]
+    }
+   ],
+   "source": [
+    "backend = Aer.get_backend('qasm_simulator')\n",
+    "quantum_instance = QuantumInstance(backend=backend, seed=167, seed_mapper=167) \n",
+    "\n",
+    "counts = []\n",
+    "values = []\n",
+    "def store_intermediate_result(eval_count, parameters, mean, std):\n",
+    "    counts.append(eval_count)\n",
+    "    values.append(mean)\n",
+    "\n",
+    "aqua_globals.random_seed = 167\n",
+    "optimizer = SPSA(max_trials=200)\n",
+    "var_form = RY(num_qubits)\n",
+    "vqe = VQE(qubit_op, var_form, optimizer, 'paulis',  callback=store_intermediate_result)\n",
+    "vqe_result = vqe.run(quantum_instance)\n",
+    "print('VQE on Aer qasm simulator (no noise): {}'.format(vqe_result['energy']))\n",
+    "print('Delta from reference: {}'.format(vqe_result['energy']-ref))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We captured the energy values above during the convergence so we can see what went on in the graph below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x7fd58dd7f208>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pylab.rcParams['figure.figsize'] = (12, 4)\n",
+    "pylab.plot(counts, values)\n",
+    "pylab.xlabel('Eval count')\n",
+    "pylab.ylabel('Energy')\n",
+    "pylab.title('Convergence with no noise');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Performance *with* noise\n",
+    "\n",
+    "Now we will add noise. Here we will create a noise model for Aer from an actual device. You can create custom noise models with Aer but that goes beyond the scope of this notebook. Links to further information on Aer noise model, for those that may be interested in doing this, were given in instruction above.\n",
+    "\n",
+    "First we need to get an actual device backend and from its `configuration` and `properties` we can   setup a coupling map and a noise model to match the device. While we could leave the simulator with the default all to all map, this shows how to set the coupling map too. Note: We can also use this coupling map as the entanglement map for the variational form if we choose.\n",
+    "\n",
+    "Note: simulation with noise takes significantly longer than without noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VQE on Aer qasm simulator (with noise): -1.6539436913665533\n",
+      "Delta from reference: 0.20333133883582666\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit.providers.aer import noise\n",
+    "\n",
+    "IBMQ.load_accounts(hub=None)\n",
+    "device = IBMQ.get_backend('ibmqx4')\n",
+    "coupling_map = device.configuration().coupling_map\n",
+    "noise_model = noise.device.basic_device_noise_model(device.properties())\n",
+    "basis_gates = noise_model.basis_gates\n",
+    "\n",
+    "backend = Aer.get_backend('qasm_simulator')\n",
+    "quantum_instance = QuantumInstance(backend=backend, seed=167, seed_mapper=167,\n",
+    "                                   coupling_map=coupling_map,\n",
+    "                                   noise_model=noise_model,\n",
+    "                                   basis_gates=basis_gates)\n",
+    "\n",
+    "counts1 = []\n",
+    "values1 = []\n",
+    "def store_intermediate_result1(eval_count, parameters, mean, std):\n",
+    "    counts1.append(eval_count)\n",
+    "    values1.append(mean)\n",
+    "\n",
+    "aqua_globals.random_seed = 167\n",
+    "optimizer = SPSA(max_trials=200)\n",
+    "var_form = RY(num_qubits)\n",
+    "vqe = VQE(qubit_op, var_form, optimizer, 'paulis',  callback=store_intermediate_result1)\n",
+    "vqe_result1 = vqe.run(quantum_instance)\n",
+    "print('VQE on Aer qasm simulator (with noise): {}'.format(vqe_result1['energy']))\n",
+    "print('Delta from reference: {}'.format(vqe_result1['energy']-ref))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x7fd58c4b7ef0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pylab.rcParams['figure.figsize'] = (12, 4)\n",
+    "pylab.plot(counts1, values1)\n",
+    "pylab.xlabel('Eval count')\n",
+    "pylab.ylabel('Energy')\n",
+    "pylab.title('Convergence with noise');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Declarative approach and noise model\n",
+    "\n",
+    "Note: if you are running an experiment using the declarative approach, with a dictionary/json, there are keywords in the `backend` section that let you define the noise model based on a device, as well as setup the coupling map too. The basis gate setup, that is shown above, will automatically be done. Here is an example of such a `backend` configuration:\n",
+    "```\n",
+    "    'backend': {   \n",
+    "\t  'provider': 'qiskit.Aer',\n",
+    "      'name': 'qasm_simulator',\n",
+    "\t  'coupling_map_from_device': 'qiskit.IBMQ:ibmqx4',\n",
+    "      'noise_model': 'qiskit.IBMQ:ibmqx4',\n",
+    "      'shots': 1024\n",
+    "\t  },\n",
+    "```\n",
+    "\n",
+    "If you call `run_algorithm` and override the `backend` section by explicity supplying a backend instance as a parameter to run_algorithm,  please note that you can provide a QuantumInstance type there instead of BaseBackend. A QuantumInstance allows you to setup and define your own custom noise model and other run time configuration. \n",
+    "\n",
+    "<span style=\"font-size:0.9em\">(Note when a BaseBackend type is supplied to run_algorithm it is internally wrapped into a QuantumInstance, with default values supplied for noise, run time parameters etc., so you do not get the opportunity that way to set a noise model etc. But by explicitly providing a QuantumInstance you can setup these aspects to your choosing.)</span>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.6.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/community/aqua/optimization/input_files/grover.json b/community/aqua/optimization/input_files/grover.json
index bbf409359..84d511af7 100644
--- a/community/aqua/optimization/input_files/grover.json
+++ b/community/aqua/optimization/input_files/grover.json
@@ -4,11 +4,12 @@
     },
     "backend": {
         "provider": "qiskit.BasicAer", 
-        "name": "qasm_simulator"
+        "name": "qasm_simulator",
+        "shots": 1000
     },
     "oracle": {
-        "expression": "p cnf 3 5 \n -1 -2 -3 0 \n 1 -2 3 0 \n 1 2 -3 0 \n 1 -2 -3 0 \n -1 2 3 0",
-        "name": "LogicExpressionOracle"
+        "expression": "c example DIMACS-CNF 3-SAT\np cnf 3 5\n-1 -2 -3 0\n1 -2 3 0\n1 2 -3 0\n1 -2 -3 0\n-1 2 3 0",
+        "name": "LogicalExpressionOracle"
     },
     "problem": {
         "name": "search"
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_0-Hello_Quantum_World/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_0-Hello_Quantum_World/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_0-Hello_Quantum_World/latex/.ipynb_checkpoints/main-checkpoint.tex b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_0-Hello_Quantum_World/latex/.ipynb_checkpoints/main-checkpoint.tex
deleted file mode 100755
index 51cf77a18..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_0-Hello_Quantum_World/latex/.ipynb_checkpoints/main-checkpoint.tex
+++ /dev/null
@@ -1,282 +0,0 @@
-\documentclass[aspectratio=43]{beamer}
-\usepackage[utf8]{inputenc}
-
-%%%%%%%%%%%%%%%%%%%%%%%% THEME
-\usetheme{material}
-\useLightTheme
-\usePrimaryTeal
-\useAccentGreen
-
-\usepackage{macros} % must come after theme
-
-\title{Hello \qw}
-\keywords{\qm,\qc}
-
-\begin{document}
-
-\begin{frame}
-	\titlepage
-\end{frame}
-
-
-\begin{frame}{Table of contents}
-	\begin{card}
-		\tableofcontents
-	\end{card}
-\end{frame}
-
-\section{Motivation}
-\begin{frame}{Motivation}
-\begin{card}[Why]
-    \begin{chapquote}[2pt]{\href{https://en.wikipedia.org/wiki/Seth_Lloyd}{Seth Lloyd}}
-        ``Classical computation is like a solo voice - one line of pure tones succeeding each other. Quantum computation is like a symphony - many lines of tones interfering with one another.''
-    \end{chapquote}
-\end{card}
-
-\pagenumber
-\end{frame}
-
-\begin{frame}{Motivation}
-\begin{card}[How]
-    \qc can be seen as leveraging the phenomena that happen at the atomic and subatomic levels - in the \qw\xspace- to produce computations that, ultimately, surpass \cc.
-\end{card}
-\pagenumber
-\end{frame}
-
-\begin{frame}{About this course}
-\begin{card}
-    This course is suited for beginners in \qm and \qc. If you are already familiar with the concepts of a given week, you are encouraged to move forward in the course. 
-    
-    This course brings novelty in that it focuses on \textbf{learning by doing}, and that is why you will also learn about \qk and \ibmqe.
-    
-    The author believes both that learning should be fun and that derision is a wonderful attention gripper, so humour will be used as the powerful tool that it is, wisely.
-\end{card}
-\pagenumber
-\end{frame}
-
-\begin{frame}{About this course - Study plan}
-\begin{card}
-    \begin{itemize}
-        \item \qm 101
-        \item \qk and \ibmqe
-        \item \qi
-        \item Designing \qcts
-        \item \qa (Deutsch, Grover, Shor)
-        \item \qc applications
-        \item \q Computers - state of the art
-        \item Implications and ethical considerations throughout
-    \end{itemize}
-\end{card}
-\pagenumber
-\end{frame}
-
-\section{Introduction}
-\begin{frame}{Introduction}
-\begin{card}
-    In this first week, we will start by defining what \qc is and how it compares to \cc. Next, a walk-through the novelty that \qm brings and how it compares to \cp.  As a starting point to understanding how these quantum properties can be used to tackle problems algorithmically, we will introduce the concepts of \textbf{superposition} and \textbf{measurement}, that of \textbf{entanglement} will be introduced later, at a stage where it makes more sense and is easier to assimilate.
-\end{card}
-\pagenumber
-\end{frame}
-
-
-\section{\qp vs \cp}
-
-\begin{frame}{\cp}
-\begin{card}
-    \cp (also \cm) describes the world \textit{as we see it}, in its macro level. Some of its properties:
-    \begin{description}
-        \item[size] objects with $size \gtrsim 1nm\ (10^{-9}m)$
-        \item[speed] objects of $speed \lesssim \speedoflight$
-    \end{description}
-\end{card}
-\pagenumber
-\end{frame}
-
-
-\begin{frame}{\qp}
-\begin{card}
-    \qp (also \qm) describes the world \textit{as we see it}, in its macro level. Some of its properties:
-    \begin{description}
-        \item[size] objects with $size \lesssim 1nm$
-        \item[speed] objects of $speed \lesssim \speedoflight$
-    \end{description}
-\end{card}
-\pagenumber
-\end{frame}
-
-\begin{frame}{The kingdoms of \cl and \qm}
-\begin{card}
-    \centering\cardImg{classical_vs_quantum_dimensions.png}{\textwidth}
-\end{card}
-\pagenumber
-\end{frame}
-
-\section{Principles of \qm}
-\subsubsection{\qsp}
-\begin{frame}{\qsp}
-    \begin{card}
-        A \q state (of a particle) can be seen as being composed by more than one different states, simultaneously. It is not in state A \textbf{or} B, it is in state A \textbf{and} state B, at the same time. This defies classical views of the world, where two things are never true at the same time and requires some mental effort!\\
-        The state is, therefore, in a kind of superposition.
-    \end{card}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qsp - Schrödinger's cat}
-    \textbf{Thought experiment:} Imagine a cat locked inside a box, along with a poison releasing mechanism. The mechanism has a 50\% chance of having been activated at the time the box is about to be opened. At that moment, we cannot be sure of the cat's living state. Perhaps, we should assume the cat is both dead and alive, at the same time. With each state having the same probability.
-    \begin{center}
-	    \cardImg{img/cat.png}{0.5\textwidth}
-    \end{center}
-    \begin{center}
-        To worlds, inside one.
-    \end{center}
-\pagenumber
-\end{frame}
-
-
-\begin{frame}{\qsp}
-    \begin{cardTiny}
-        Formally, such states are represented using the \textbf{Ket notation} (as defined by \textit{Paul Dirac}). State 0 would be \ket{0}. 
-    \end{cardTiny}
-    \begin{cardTiny}
-        \begin{multicols}{2}
-    		Consider the electron of a Hydrogen atom, orbiting around the nucleus, with only two (simplification) possible energy states. As this is a \q particle, these energy states are quantized, that is, they take only discrete (quantified) values. 
-    		\begin{center}
-    		\includegraphics[width=0.4\textwidth]{hydrogen}
-    		\end{center}
-	    \end{multicols}
-    \end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qsp}
-    \begin{card}
-        When we have no evidence of the electron's state, we assume that it is in a superposition of both positions. This \qsp $\ket{\phi}$ is written as:
-	\begin{equation*}
-	    \superpos
-	\end{equation*}
-    \end{card}
-    \begin{cardTiny}
-        $\alpha$ and $\beta$ represent how likely each of the two states is. These are complex numbers such that $|\alpha|^2 + |\beta|^2 = 1$. 
-    \end{cardTiny}
-    \begin{cardTiny}
-        \small{
-        So, why and how does \qsp actually work?\\ \textbf{We do not know!} (this statement pops up frequently in \q) However, some \href{https://arxiv.org/abs/1707.09483}{interesting experiments} might just be able to answer us soon enough...
-        }
-    \end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qsp\space-  Plane representation}
-    \begin{cardTiny}
-        \begin{multicols}{2}
-    		Another important remark to make is that a superposition can be projected as unit vector onto a 2D plane (even though $\alpha$ and $\beta$ are complex numbers). In essence, this allows us to convert a superposition in the $\ket{0}\ket{1}$ basis, as is $\ket{\psi}$, onto other basis. Basis are orthonormal.
-    		\begin{center}
-                \input{mathcha/superpos_projection.tex}
-    		\end{center}
-	    \end{multicols}
-    \end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qsp\space- Vector representation}
-    \begin{cardTiny}
-        Moreover, a quantum state $\superpos$ can be seen as a unit vector in the complex bi-dimensional space ($\mathbb{C}^2$) \begin{bmatrix}$\alpha$ \\ $\beta$\end{bmatrix}, such that:
-        \begin{equation*}
-            \alpha \ket{0} + \beta \ket{1} = 
-            \begin{bmatrix}$\alpha$ \\ $\beta$\end{bmatrix}^\intercal 
-            \times
-            \begin{bmatrix}1 & 0\\ 0 & 1\end{bmatrix}
-        \end{equation*}
-        Given the following as the basis vectors (this is the zero-one basis):
-        \begin{equation*}
-            \ket{0} =  \begin{bmatrix}1 \\ 0\end{bmatrix},\\
-            \ket{1} =  \begin{bmatrix}0 \\ 1\end{bmatrix}
-        \end{equation*}
-    \end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qsp\space- Basis}
-    \begin{multicols}{2}
-        As a matter of fact, any linearly independent pair of unit vectors can act as basis. One well known basis is the $\ket{+}\ket{-}$ (plus-minus) basis:
-        \begin{equation*}
-            \ket{+} =  \begin{bmatrix}\osqrt \\ \osqrt\end{bmatrix},\\
-            \ket{-} =  \begin{bmatrix}\osqrt \\ -\osqrt\end{bmatrix}
-        \end{equation*}
-        This is simply the $\ket{0}\ket{1}$ basis rotated by $\frac{\pi}{4}$($45º$).
-		\begin{center}
-            \input{mathcha/plus_minus.tex}
-		\end{center}
-    \end{multicols}
-\pagenumber
-\end{frame}
-
-
-
-
-\subsubsection{\qmt}
-\begin{frame}{\qmt}
-    \begin{cardTiny}
-        From a pragmatic perspective, what happens when we open the box and look at the cat? From that moment on, only one state remains, either death \textbf{or} life. And we cannot close the box again and expect a different outcome.
-    \end{cardTiny}
-    \begin{cardTiny}
-        \centering\textit{The cat is out of the box.}
-    \end{cardTiny}
-    \begin{cardTiny}
-        A \textbf{Measurement} causes the system to stabilise, in a non-reversible way. When we perform a measurement  on the electron's state (let this process be a technicality, for now), we get $\ket{0}$ \textbf{or} $\ket{1}$. If we repeat the measurement, the result will be the same, \textbf{always}. 
-    \end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qmt}
-\begin{cardTiny}
-\small{
-    To better understand what a measurement is, it is important to understand that it is \textbf{basis-specific}, meaning we could measure on the $\ket{0}\ket{1}$ or on the $\ket{+}\ket{-}$ basis (or another \href{http://mathworld.wolfram.com/LinearlyIndependent.html}{LI}). Example:\\
-    You have a qubit in a superposition $\osqrt\alpha+\osqrt\beta$, you measure (zero-one basis) it into a bit and the result is 0 (horizontal). Now, if you convert it to the plus-minus basis you will get $\psi = \osqrt\ket{+} + \osqrt\ket{-}$.\\
-    Imagine that the measurement had not happened and was instead performed on the plus-minus basis, the result would be $+$ (since $\ket{+}=\osqrt\ket{0}+\osqrt\ket{1}$).
-}
-\end{cardTiny}
-\begin{cardTiny}
-    \small{You can now see the impact of choosing a given basis to perform a measurement. We will return to this later, the simple notion of this consideration is what you should absorb now.}
-\end{cardTiny}
-\pagenumber
-\end{frame}
-
-\begin{frame}{\qmt}
-\begin{cardTiny}
-\small{
-    Pragmatically speaking, \qmt requires a few considerations. Firstly, it produces a single output form a state that is stochastic, meaning that doing it once is not enough to be sure of the probability distribution. So, typically, each experiment is executed a large number of times (hundreds and sometimes thousands) so that the confidence in the results meets the expectations.\\
-    Furthermore, as you will see when deploying to real quantum devices, current experimental setups are not perfect (and hardly ever will be) so even the simplest of programs may produce buggy results and a \q Scientist should be aware of it.\\As a matter of fact \href{https://quantumexperience.ng.bluemix.net/qx/editor}{\ibmqe}'s devices are usually well described even in the average error (noise) ratios you should expect.
-}
-\end{cardTiny}
-\pagenumber
-\end{frame}
-
-\section{Why \q?}
-\begin{frame}{Why \q?}
-    To end this introductory week to the \qw, there are a few useful considerations to make:
-    \begin{itemize}
-        \item \qc is worth our time because it brings the promise of revolutionising the amount of computation within human reach, from tackling currently impossible problems to rendering most encryption standards useless.
-        \item \qc works because it allows for the massive parallelisation of computations hitherto unattainable with such ease in \cc, because humans are not defining this parallelism, Mother Nature is! That and the \qm at play (some yet to see) give it even more out-of-the-box characteristics adding to its enormous potential. 
-    \end{itemize}
-\pagenumber
-\end{frame}
-
-\begin{frameImg}[width]{dilbert}
-
-
-\end{frameImg}
-
-\section{Where to learn more?}
-\begin{frame}{Where to learn more?}
-\begin{card}
-    \begin{itemize}
-        \item \href{https://www.quantiki.org/wiki/introduction-quantum-theory}{Introduction to Quantum Theory, Quantiki}
-        \item \href{https://www.khanacademy.org/science/physics/quantum-physics/quantum-numbers-and-orbitals/a/the-quantum-mechanical-model-of-the-atom}{Khan Academy, The quantum mechanical model of the atom}
-        \item \href{https://www.goodreads.com/book/show/331680.Programming_the_Universe}{Programming the Universe: A Quantum Computer Scientist Takes on the Cosmos}
-        \item \href{https://www.goodreads.com/book/show/260142.The_Principles_of_Quantum_Mechanics}{The Principles of Quantum Mechanics, \textit{Paul Dirac}}
-    \end{itemize}
-\end{card}
-\end{frame}
-
-\end{document}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 0fbb6545c..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,56 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 1 - Quantum Tools\n",
-    "\n",
-    " * Python and Pip\n",
-    " * Jupyter\n",
-    " * Google Colaboratory\n",
-    " * Binder\n",
-    " * Qiskit (and its composing parts)\n",
-    " * Community and VSCode extension\n",
-    " * IBMQ and IBMQ Experience\n",
-    " \n",
-    "# Exercises\n",
-    " * Installing software\n",
-    " * Creating IBMQ account\n",
-    " * Local setup by running [this notebook](exercises/IBMQ_setup.ipynb) on your machine. (You can [clone](https://help.github.com/articles/cloning-a-repository/) or download this repo)\n",
-    " \n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 74251cabe..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Week 1 - Quantum Tools
-
- * Python and Pip
- * Jupyter
- * Google Colaboratory
- * Binder
- * Qiskit (and its composing parts)
- * Community and VSCode extension
- * IBMQ and IBMQ Experience
- 
-# Exercises
- * Installing software
- * Creating IBMQ account
- * Local setup by running [this notebook](exercises/IBMQ_setup.ipynb) on your machine. (You can [clone](https://help.github.com/articles/cloning-a-repository/) or download this repo)
- 
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/slides-checkpoint.pdf b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/slides-checkpoint.pdf
deleted file mode 100755
index bcddb6326..000000000
Binary files a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/.ipynb_checkpoints/slides-checkpoint.pdf and /dev/null differ
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/IBMQ_setup-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/IBMQ_setup-checkpoint.ipynb
deleted file mode 100755
index 048be9731..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/IBMQ_setup-checkpoint.ipynb
+++ /dev/null
@@ -1,192 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"qiskit-heading.gif\" width=\"500 px\" align=\"center\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# IBM Q setup\n",
-    "This tutorial will walk you through the configuration for your IBM Q Experience account so that, in the future, you are able to run your Quantum Programs in both online simulators as well as real Quantum Computers.\n",
-    "\n",
-    "We assume you have installed Qiskit if not please look at [qiskit.org](http://www.qiskit.org) or the install [documentation](https://github.com/qiskit/qiskit-tutorial/blob/master/INSTALL.md). \n",
-    "\n",
-    "To test this run the following commands"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import qiskit"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Execute on a Real Device (IBM Q Experience)\n",
-    "\n",
-    "You can use Qiskit to run your circuits on real quantum computers using the IBMQ provider. They are small and noisy but are advancing at a fast pace. In the future, more information will be given regarding this environment, but for now lets go ahead and set it up!\n",
-    "\n",
-    "To access IBMQ devices, you'll need an API token. For the public Quantum Experience devices, you can generate an API token [here](https://quantumexperience.ng.bluemix.net/qx/account/advanced) (create an account if you don't already have one). For Q Network devices, login to the q-console, click your hub, group, and project, and expand \"Get Access\" to generate your API token and access url."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import IBMQ # requires qiskit version >= 0.6"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "After generating your API token, call:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.save_account(\"MY_TOKEN\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For Q Network users, you'll also need to include your access url:\n",
-    "\n",
-    "`IBMQ.save_account('MY_TOKEN', 'URL')`\n",
-    "\n",
-    "This will store your IBMQ credentials in a local file. Unless your registration information has changed, you only need to do this once. \n",
-    "\n",
-    "You may now (or in any other exercise) load your accounts by calling:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.load_accounts()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Which Backends are available right now?\n",
-    "A backend is either an online Quantum simulator or a Quantum Computer.\n",
-    "\n",
-    "This is how you can list them by name:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ibmqx4\n",
-      "ibmqx5\n",
-      "ibmqx2\n",
-      "ibmq_16_melbourne\n",
-      "ibmq_qasm_simulator\n"
-     ]
-    }
-   ],
-   "source": [
-    "for backend in IBMQ.backends():\n",
-    "    print(backend)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Additionally, you can get all of their configurations, like so:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'local': False, 'name': 'ibmqx4', 'version': '1.2.0', 'description': '5 qubit transmon bowtie chip 3', 'gate_set': 'SU2+CNOT', 'basis_gates': 'u1,u2,u3,cx,id', 'online_date': '2017-09-18T00:00:00.000Z', 'chip_name': 'Raven', 'deleted': False, 'url': 'https://ibm.biz/qiskit-ibmqx4', 'internal_id': '5ae875670f020500393162b3', 'simulator': False, 'allow_q_object': False, 'n_qubits': 5, 'coupling_map': [[1, 0], [2, 0], [2, 1], [3, 2], [3, 4], [4, 2]]}\n"
-     ]
-    }
-   ],
-   "source": [
-    "backend_0 = IBMQ.backends()[0] # retrieve the Backend at index 0\n",
-    "print(backend_0.configuration())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Go check its specification at https://ibm.biz/qiskit-ibmqx4\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Go check its specification at %s\" % backend_0.configuration()[\"url\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "That's it for this week, if you have reached this point your local machine is now ready for the next steps 💪"
-   ]
-  }
- ],
- "metadata": {
-  "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.6.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index f6524f95a..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,49 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Overview\n",
-    "\n",
-    "For this week, there are some boring tasks:\n",
-    " * Install Python (and pip)\n",
-    " * Install Jupyter\n",
-    " * Install QSKit\n",
-    " *  Create an account on IBM Q Experience\n",
-    " \n",
-    "As well as some interesting tasks:\n",
-    " * Checkout the community for QSKit\n",
-    " * Follow this week's Jupyter Notebook (local setup of IBM Q account)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/IBMQ_setup.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/IBMQ_setup.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_1-Quantum_Tools/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 77cc398ad..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,54 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 2 - Quantum Information Science\n",
-    "\n",
-    " * Quantum Information Science\n",
-    " * Classical bits/egisters\n",
-    " * Quantum bits/registers\n",
-    " * Hands-on on Qskit\n",
-    " * Visualizing circuits\n",
-    " * Qasm language\n",
-    " \n",
-    "# Exercises\n",
-    " * [QSKit basics and circuit visualization](exercises/w2_01.ipynb)\n",
-    " * Run a Qasm specification on IBM Q Experience, and on a Real Processor (see slides for instructions)\n",
-    " \n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 83057c0cc..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Week 2 - Quantum Information Science
-
- * Quantum Information Science
- * Classical bits/egisters
- * Quantum bits/registers
- * Hands-on on Qskit
- * Visualizing circuits
- * Qasm language
- 
-# Exercises
- * [QSKit basics and circuit visualization](exercises/w2_01.ipynb)
- * Run a Qasm specification on IBM Q Experience, and on a Real Processor (see slides for instructions)
- 
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 0a8d7d45b..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * [QSKit basics and circuit visualization](w2_01.ipynb)\n",
-    " * Run a Qasm specification on IBM Q Experience, and on a Real Processor (see slides for instructions)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/w2_01-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/w2_01-checkpoint.ipynb
deleted file mode 100755
index e6d3486ea..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/.ipynb_checkpoints/w2_01-checkpoint.ipynb
+++ /dev/null
@@ -1,216 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classical and Quantum Registers in Qiskit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import ClassicalRegister\n",
-    "# Create a Classical Register with 2 bits.\n",
-    "c = ClassicalRegister(2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import QuantumRegister\n",
-    "# Create a Quantum Register with 2 qubits.\n",
-    "q = QuantumRegister(2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Quantum Circuits in Qiskit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import QuantumCircuit\n",
-    "# Create a Quantum Circuit\n",
-    "qc = QuantumCircuit(q, c)\n",
-    "# perform a measurement of our qubits into our bits\n",
-    "qc.measure(q, c); # ; hides the output"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Visualization\n",
-    "There are two options:\n",
-    " * [matplotlib](https://matplotlib.org/) which is a python module (`pip install matplotlib`)\n",
-    " * LaTeX visualization, which requires some more configuration, check the [official instructions](https://github.com/Qiskit/qiskit-tutorial/blob/master/INSTALL.md#5-visualizing-circuits-with-latex) for configuration. This was an old feature and is therefore less important to us."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Matplotlib"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Jupyter command to activate matplotlib and allow the preview of our circuit\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x1b611e296d8>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as draw\n",
-    "draw(qc) # visualize quantum circuit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=326x284 at 0x1B6143F8A58>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Try both and use the one you like best\n",
-    "from qiskit.tools.visualization import circuit_drawer as draw2\n",
-    "draw2(qc) # visualize quantum circuit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# if you want to save it to a file\n",
-    "from qiskit.tools.visualization import circuit_drawer\n",
-    "diagram = circuit_drawer(qc, filename=\"my_first_quantum_circuit.png\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "diagram.show() # or even open it on an external program (no need to save first)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Open Quantum Assembly Language (QASM)\n",
-    "To learn more about this standard, check [the original paper](https://arxiv.org/abs/1707.03429), the [github repo](https://github.com/Qiskit/openqasm), the [language documentation](https://github.com/Qiskit/openqasm/blob/master/spec/qasm2.rst) and the [wikipedia entry](https://en.wikipedia.org/wiki/OpenQASM)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OPENQASM 2.0;\n",
-      "include \"qelib1.inc\";\n",
-      "qreg q0[2];\n",
-      "creg c0[2];\n",
-      "measure q0[0] -> c0[0];\n",
-      "measure q0[1] -> c0[1];\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# get the QASM representation of our circuit\n",
-    "print(qc.qasm())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Suggested exercises\n",
-    "\n",
-    "* Change the number of bits in the classical register to a negative number.\n",
-    "\n",
-    "`That is your first QiskitError error and they are usually easy to interpret.`\n",
-    "* Change the number of bits in the quantum register to a positive number not equal to 2 (5 for example) and run the blocks until you get an error, try to understand it.\n",
-    "\n",
-    "`This is because you cannot read 5 qubits into 2 bits without losing information!`\n",
-    "* Now, update the number of bits accordingly and visualize your circuit.\n",
-    "\n",
-    "`Guarantee that the changes in the circuit diagram make sense`\n",
-    "* You can keep on trying to tweek with some settings, for instance, you can *name* your registers, like `c = ClassicalRegister(2, name=\"class\")` and this will reflect in the diagram.\n",
-    "* Checkout more [configuration options](https://github.com/Qiskit/qiskit-tutorial/blob/master/qiskit/basics/circuit_drawing.ipynb#Visualize%20Circuit) for the layout of your diagrams"
-   ]
-  }
- ],
- "metadata": {
-  "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.6.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/w2_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_2-Quantum_Information_Science/exercises/w2_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 34988414e..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,56 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 3 - Quantum Gates\n",
-    "\n",
-    " * Algebra reminders: Conjugate Transpose, Hermitian, Unitary operators\n",
-    " * Quantum Gates\n",
-    " * one qubit gates: Hadamard, Pauli gates (X, Y, Z)\n",
-    " * \\>1 qubit gates: Controlled gates, CNOT\n",
-    " * Preview of other gates\n",
-    " * Qiskit examples\n",
-    " * Circuit representation of gates\n",
-    "\n",
-    "# Exercises\n",
-    " * Pen and paper exercises for testing unitary transformations [slides](slides.pdf)\n",
-    " * [Jupyter notebook with exercises](exercises/w3_01.ipynb): implementing gates, visualizing, executing locally and in remote machines, implement some simple circuits, discussion on practical setups\n",
-    " * [Jupyter notebook with solutions](exercises/w3_01_s.ipynb)\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index c7d9d48e9..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Week 3 - Quantum Gates
-
- * Algebra reminders: Conjugate Transpose, Hermitian, Unitary operators
- * Quantum Gates
- * one qubit gates: Hadamard, Pauli gates (X, Y, Z)
- * \>1 qubit gates: Controlled gates, CNOT
- * Preview of other gates
- * Qiskit examples
- * Circuit representation of gates
-
-# Exercises
- * Pen and paper exercises for testing unitary transformations [slides](slides.pdf)
- * [Jupyter notebook with exercises](exercises/w3_01.ipynb): implementing gates, visualizing, executing locally and in remote machines, implement some simple circuits, discussion on practical setups
- * [Jupyter notebook with solutions](exercises/w3_01_s.ipynb)
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 0e046deef..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,42 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * Pen and paper exercises for testing unitary transformations [slides](../slides.pdf)\n",
-    " * [Jupyter notebook with exercises](w3_01.ipynb): implementing gates, visualizing, executing locally and in remote machines, implement some simple circuits, discussion on practical setups\n",
-    " * [Jupyter notebook with solutions](w3_01_s.ipynb)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/w3_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/w3_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/w3_01_s.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_3-Quantum_Gates/exercises/w3_01_s.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 65826ab36..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,55 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 4 - Quantum Facts\n",
-    "\n",
-    " * Universal Classical Gates\n",
-    " * Universal Quantum Gates\n",
-    " * How unitary transformations allow for cyclic basis conversion\n",
-    " * Entanglement\n",
-    " * Big O Notation\n",
-    " * BQP\n",
-    "\n",
-    "# Exercises\n",
-    " * Pen and paper exercises for basis conversion using single qubit gates [slides](slides.pdf)\n",
-    " * [Jupyter notebook with exercises](exercises/w4_01.ipynb): implementing and understanding entanglement, observing entanglement in lab settings\n",
-    " * [Jupyter notebook with solutions](exercises/w4_01_s.ipynb)\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index a4a1b7646..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Week 4 - Quantum Facts
-
- * Universal Classical Gates
- * Universal Quantum Gates
- * How unitary transformations allow for cyclic basis conversion
- * Entanglement
- * Big O Notation
- * BQP
-
-# Exercises
- * Pen and paper exercises for basis conversion using single qubit gates [slides](slides.pdf)
- * [Jupyter notebook with exercises](exercises/w4_01.ipynb): implementing and understanding entanglement, observing entanglement in lab settings
- * [Jupyter notebook with solutions](exercises/w4_01_s.ipynb)
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index f3fad80cd..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,42 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * Pen and paper exercises for basis conversion using single qubit gates [../slides](slides.pdf)\n",
-    " * [Jupyter notebook with exercises](w4_01.ipynb): implementing and understanding entanglement, observing entanglement in lab settings\n",
-    " * [Jupyter notebook with solutions](w4_01_s.ipynb)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/w4_01_s-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/w4_01_s-checkpoint.ipynb
deleted file mode 100755
index 3b56ddfa9..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/.ipynb_checkpoints/w4_01_s-checkpoint.ipynb
+++ /dev/null
@@ -1,789 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Quantum Facts in Qiskit\n",
-    "Here some useful topics will be covered and others recalled to make you more familiar with quantum terms and concepts.\n",
-    "\n",
-    "Start by some typical setup and definition of useful functions, which you are encouraged to look at.\n",
-    "\n",
-    "Then, head to the [exercises start](#Exercises-Start-Here) to start coding!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister\n",
-    "from qiskit import execute"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Choose the drawer you like best:\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as draw\n",
-    "#from qiskit.tools.visualization import circuit_drawer as draw"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import IBMQ\n",
-    "IBMQ.load_accounts() # make sure you have setup your token locally to use this"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Utils for visualizing experimental results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "def show_results(D):\n",
-    "    # D is a dictionary with classical bits as keys and count as value\n",
-    "    # example: D = {'000': 497, '001': 527}\n",
-    "    plt.bar(range(len(D)), list(D.values()), align='center')\n",
-    "    plt.xticks(range(len(D)), list(D.keys()))\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Utils for executing circuits"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Aer backends:  [<QasmSimulator('qasm_simulator') from Aer()>, <QasmSimulatorPy('qasm_simulator_py') from Aer()>, <StatevectorSimulator('statevector_simulator') from Aer()>, <StatevectorSimulatorPy('statevector_simulator_py') from Aer()>, <UnitarySimulator('unitary_simulator') from Aer()>, <CliffordSimulator('clifford_simulator') from Aer()>]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit import Aer\n",
-    "# See a list of available local simulators\n",
-    "print(\"Aer backends: \", Aer.backends())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "IBMQ Backends:  [<IBMQBackend('ibmqx4') from IBMQ()>, <IBMQBackend('ibmqx5') from IBMQ()>, <IBMQBackend('ibmqx2') from IBMQ()>, <IBMQBackend('ibmq_16_melbourne') from IBMQ()>, <IBMQBackend('ibmq_qasm_simulator') from IBMQ()>]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# see a list of available remote backends (these are freely given by IBM)\n",
-    "print(\"IBMQ Backends: \", IBMQ.backends())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Execute locally"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# execute circuit and either display a histogram of the results\n",
-    "def execute_locally(qc, draw_circuit=False):\n",
-    "    # Compile and run the Quantum circuit on a simulator backend\n",
-    "    backend_sim = Aer.get_backend('qasm_simulator')\n",
-    "    job_sim = execute(qc, backend_sim)\n",
-    "    result_sim = job_sim.result()\n",
-    "    result_counts = result_sim.get_counts(qc)\n",
-    "    \n",
-    "    # Print the results\n",
-    "    print(\"simulation: \", result_sim, result_counts)\n",
-    "    \n",
-    "    if draw_circuit: # draw the circuit\n",
-    "        draw(qc)\n",
-    "    else: # or show the results\n",
-    "        show_results(result_counts)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Execute remotely"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.backends.ibmq import least_busy\n",
-    "import time\n",
-    "# Compile and run on a real device backend\n",
-    "def execute_remotely(qc, draw_circuit=False):\n",
-    "    if draw_circuit: # draw the circuit\n",
-    "        draw(qc)\n",
-    "    try:\n",
-    "        # select least busy available device and execute.\n",
-    "        least_busy_device = least_busy(IBMQ.backends(simulator=False))\n",
-    "        print(\"Running on current least busy device: \", least_busy_device)\n",
-    "\n",
-    "        # running the job\n",
-    "        job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)\n",
-    "\n",
-    "        lapse, interval = 0, 10\n",
-    "        while job_exp.status().name != 'DONE':\n",
-    "            print('Status @ {} seconds'.format(interval * lapse))\n",
-    "            print(job_exp.status())\n",
-    "            time.sleep(interval)\n",
-    "            lapse += 1\n",
-    "        print(job_exp.status())\n",
-    "        exp_result = job_exp.result()\n",
-    "        result_counts = exp_result.get_counts(qc)\n",
-    "\n",
-    "        # Show the results\n",
-    "        print(\"experiment: \", exp_result, result_counts)\n",
-    "        if not draw_circuit: # show the results\n",
-    "            show_results(result_counts)\n",
-    "    except:\n",
-    "        print(\"All devices are currently unavailable.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Building the circuit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def new_circuit(size):\n",
-    "    # Create a Quantum Register with size qubits\n",
-    "    qr = QuantumRegister(size)\n",
-    "\n",
-    "    # Create a Classical Register with size bits\n",
-    "    cr = ClassicalRegister(size)\n",
-    "\n",
-    "    # Create a Quantum Circuit acting on the qr and cr register\n",
-    "    return qr, cr, QuantumCircuit(qr, cr)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "<h1 align=\"center\">Exercises Start Here</h1>\n",
-    "\n",
-    "Make sure you ran all the above cells in order, as the following exercises use functions defined and imported above."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Creating Entanglement\n",
-    "Although, you have already entangled qubits on the previous week, you were not aware of it.\n",
-    "\n",
-    "Naturally, we will redo some of those tasks and focus on interpreting their results."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Hadamard + CNOT\n",
-    "\n",
-    "**TASK:** Create a new circuit with 2 qubits using `new_circuit` (very useful to reconstruct your circuit in Jupyter)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "qr, cr, circuit = new_circuit(2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add a Hadamard on qubit 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# H gate on qubit 0\n",
-    "circuit.h(qr[0]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add a CX (CNOT) gate on control qubit 0 and target qubit 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "circuit.cx(qr[0], qr[1]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Perform a measurement"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# measure the qubits\n",
-    "circuit.measure(qr, cr);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** check the result using `execute_locally` test both `True` and `False` for the `draw_circuit` option"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "simulation:  COMPLETED {'00': 504, '11': 520}\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x2276a25a748>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Try both commands:\n",
-    "execute_locally(circuit,draw_circuit=True)\n",
-    "# execute_locally(circuit,draw_circuit=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The result should be something like `COMPLETED {'00': 506, '11': 518}`.\n",
-    "\n",
-    "**TASK:** What does this mean?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> Given two qubits, we could end up with the measurements `00`, `01`, `10` and `11` (4 possibilities)\n",
-    "> \n",
-    "> However, we got only `00` and `11` (2 cases)! This is due to the fact that our qubits are **entangled**!\n",
-    ">\n",
-    "> The state of qubit 1 is correlated to that of qubit 0 (control bit). Correlation means the implication is true in both directions.\n",
-    ">\n",
-    "> By making them entangled, we have ensured that `00` and `11` are the only possible states: if qubit 0 measures to 1 the other qubit, according to our circuit, could never have been 0, as it will be flipped from a starting state of 0.\n",
-    ">\n",
-    "> Furthermore, we could apply the gates, take both qubits elsewhere (apart from each other) without destroying any superposition, perform the measurements and the result would not change... curious, right?\n",
-    ">\n",
-    "> This particular disposition of entangled qubits describes what is known as a [Bell state](https://en.wikipedia.org/wiki/Bell_state). "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Bell state in IBMQ\n",
-    "**TASK:** Get the QASM specification for your code and use it on [IBMQ QASM editor](https://quantumexperience.ng.bluemix.net/qx/qasm)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OPENQASM 2.0;\n",
-      "include \"qelib1.inc\";\n",
-      "qreg q0[2];\n",
-      "creg c0[2];\n",
-      "h q0[0];\n",
-      "cx q0[0],q0[1];\n",
-      "measure q0[0] -> c0[0];\n",
-      "measure q0[1] -> c0[1];\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(circuit.qasm())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> You will probably get an error for trying to execute this QASM, like:\n",
-    ">\n",
-    "> `Error in line 6: CX gate between q2[0], q2[1] is not allowed in this topology`\n",
-    ">\n",
-    "> To sort it, simply apply the Hadamard to `q2[1]` and change the CNOT to `cx q2[1] q2[0]`:\n",
-    "```qasm\n",
-    "OPENQASM 2.0;\n",
-    "include \"qelib1.inc\";\n",
-    "qreg q2[2];\n",
-    "creg c2[2];\n",
-    "h q2[1];\n",
-    "cx q2[1],q2[0];\n",
-    "measure q2[0] -> c2[0];\n",
-    "measure q2[1] -> c2[1];\n",
-    "```\n",
-    "> This is exactly the same circuit, but the norm seems to prefer this orientation rather than our original one (With the control qubit on the CNOT underneath the target qubit)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "### More entanglement\n",
-    "**TASK:** Repeat the previous circuit, but add a bit-flip on the target qubit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# create the circuit\n",
-    "qr, cr, circuit = new_circuit(2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add a Hadamard on qubit 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# H gate on qubit 0\n",
-    "circuit.h(qr[0]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add an X gate on qubit 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# X gate on qubit 1\n",
-    "circuit.x(qr[1]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add a CX (CNOT) gate on control qubit 0 and target qubit 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "circuit.cx(qr[0], qr[1]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Perform a measurement"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# measure the qubits\n",
-    "circuit.measure(qr, cr);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** check the result using `execute_locally` test both `True` and `False` for the `draw_circuit` option"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "simulation:  COMPLETED {'01': 513, '10': 511}\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x2276c2fb780>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Try both commands:\n",
-    "execute_locally(circuit,draw_circuit=True)\n",
-    "# execute_locally(circuit,draw_circuit=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Observe the results"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> The same phenomena happened, however the states now were `01` and `10`, only 2 out of 4 possibilities!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Quantum measurement in different basis\n",
-    "Given any of our previous circuits, we are going to measure them on both the zero-one basis as well as on the plus-minus basis."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Reconstruct one of the previous circuits (do not apply the measurement yet)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# create the circuit\n",
-    "qr, cr, circuit = new_circuit(2)\n",
-    "circuit.h(qr[0])\n",
-    "circuit.cx(qr[0], qr[1]);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Add a Hadamard after each qubit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "circuit.h(qr);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** perform the measurement now and execute"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "simulation:  COMPLETED {'00': 517, '11': 507}\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x2276c4e1e48>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "circuit.measure(qr, cr)\n",
-    "execute_locally(circuit,draw_circuit=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Why is this measurement different from the previous one?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> Since we applied the Hadamard gate on our qubits, their superposition was shifted accordingly, meaning the $\\alpha$ and $\\beta$ on the superposition were rotated by 45º. Once we measure, now, the result should be interpreted in the plus-minus basis, meaning that 1 is |+> and 0 is |->."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Free flow\n",
-    "Take a look at the following explanation of Entanglement, taken from the [qiskit-tutorial](https://github.com/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_intro/entanglement_introduction.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Entanglement\n",
-    "\n",
-    "The core idea behind the second Principle is *entanglement*. Upon reading the Principle, one might be inclined to think that entanglement is simply strong correlation between two entitities -- but entanglement goes well beyond mere perfect (classical) correlation. If you and I read the same paper, we will have learned the same information. If a third person comes along and reads the same paper they <i>also</i> will have learned this information. All three persons in this case are perfectly correlated, and they will remain correlated even if they are separated from each other. \n",
-    "\n",
-    "The situation with quantum entanglement is a bit more subtle. In the quantum world, you and I could read the same quantum paper, and yet we will not learn what information is actually contained in the paper until we get together and share our information. However, when we are together, we find that we can unlock more information from the paper than we initially thought possible. Thus, quantum entanglement goes much further than perfect correlation.\n",
-    "\n",
-    "To demonstrate this, we will define the controlled-NOT (CNOT) gate and the composition of two systems. The convention we use Qiskit is to label states by writing the first qubit's name in the rightmost position, thereby allowing us to easily convert from binary to decimal. As a result, we define the tensor product between operators $q_0$ and $q_1$ by $q_1\\otimes q_0$. \n",
-    "\n",
-    "Taking $q_0$ as the control and $q_1$ as the target, the CNOT with this representation is given by\n",
-    "\n",
-    "$$ CNOT =\\begin{pmatrix} 1 & 0 & 0 & 0\\\\ 0 & 0 & 0 & 1\\\\0& 0& 1 & 0\\\\0 & 1 & 0 & 0 \\end{pmatrix},$$\n",
-    "\n",
-    "which is non-standard in the quantum community, but more easily connects to classical computing, where the least significant bit (LSB) is typically on the right. An entangled state of the two qubits can be made via an $H$ gate on the control qubit, followed by the CNOT gate. This generates a particular maximally entangled two-qubit state known as a Bell state, named after John Stewart Bell ([learn more about Bell and his contributions to quantum physics and entanglement](https://en.wikipedia.org/wiki/John_Stewart_Bell)). \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Entanglement on a real device\n",
-    "**TASK:** Create a simple entanglement and execute it on a real device."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "qr, cr, circuit = new_circuit(2)\n",
-    "circuit.h(qr[0])\n",
-    "circuit.cx(qr[0], qr[1])\n",
-    "circuit.h(qr)\n",
-    "circuit.measure(qr, cr);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running on current least busy device:  ibmq_16_melbourne\n",
-      "Status @ 0 seconds\n",
-      "JobStatus.INITIALIZING\n",
-      "Status @ 10 seconds\n",
-      "JobStatus.QUEUED\n",
-      "Status @ 20 seconds\n",
-      "JobStatus.QUEUED\n",
-      "Status @ 30 seconds\n",
-      "JobStatus.QUEUED\n",
-      "Status @ 40 seconds\n",
-      "JobStatus.QUEUED\n",
-      "Status @ 50 seconds\n",
-      "JobStatus.RUNNING\n",
-      "Status @ 60 seconds\n",
-      "JobStatus.RUNNING\n",
-      "JobStatus.DONE\n",
-      "experiment:  COMPLETED {'00': 455, '01': 41, '10': 51, '11': 477}\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x2276c5acbe0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "execute_remotely(circuit)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**TASK:** Comment on the results"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> \n",
-    "**Important:** Once you get the results, you may see that, in fact, most of the iterations resulted in `00` and `11`. The remaining options `01` and `10` are due to the immense difficulty with which quantum entanglement is preserved in nowadays labs' conditions. Nonetheless, these are still extraordinary results!"
-   ]
-  }
- ],
- "metadata": {
-  "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.6.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/w4_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/w4_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/w4_01_s.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_4-Quantum_Facts/exercises/w4_01_s.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 17bd989b1..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,56 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 5 - Quantum Algorithms (Introdution)\n",
-    "\n",
-    " * Quantum Oracles\n",
-    " * Quantum Reversible Computation\n",
-    " * Deutsch-Jozsa Problem Formulation\n",
-    " * Deutsch's Problem Formulation\n",
-    " * Deutsch's Algorithm\n",
-    " * Deutsch-Jozsa Algorithm\n",
-    " * Deutsch/Deutsch-Jozsa in Qiskit\n",
-    "\n",
-    "# Exercises\n",
-    " * Pen and paper verificatio of the math in the description of Deutsch's Algorithm [slides](slides.pdf)\n",
-    " * [Jupyter notebook with exercises](exercises/w5_01.ipynb): implementing Deutsch's Algorithm in Qiskit\n",
-    " * [Jupyter notebook with solutions](exercises/w5_01_s.ipynb)\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 491d34f91..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Week 5 - Quantum Algorithms (Introdution)
-
- * Quantum Oracles
- * Quantum Reversible Computation
- * Deutsch-Jozsa Problem Formulation
- * Deutsch's Problem Formulation
- * Deutsch's Algorithm
- * Deutsch-Jozsa Algorithm
- * Deutsch/Deutsch-Jozsa in Qiskit
-
-# Exercises
- * Pen and paper verificatio of the math in the description of Deutsch's Algorithm [slides](slides.pdf)
- * [Jupyter notebook with exercises](exercises/w5_01.ipynb): implementing Deutsch's Algorithm in Qiskit
- * [Jupyter notebook with solutions](exercises/w5_01_s.ipynb)
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index f7e1efa94..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,43 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "# Exercises\n",
-    " * Pen and paper verificatio of the math in the description of Deutsch's Algorithm [slides](../slides.pdf)\n",
-    " * [Jupyter notebook with exercises](w5_01.ipynb): implementing Deutsch's Algorithm in Qiskit\n",
-    " * [Jupyter notebook with solutions](w5_01_s.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/w5_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/w5_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/w5_01_s.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_5-Quantum_Algorithms/exercises/w5_01_s.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index aae390012..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,53 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 6 - Quantum Search (Grover's Algorithm)\n",
-    "\n",
-    " * The Search Problem\n",
-    " * SAT Problem\n",
-    " * Grover's Algorithm Overview\n",
-    " * Phase Inversion\n",
-    " * Inversion about the Mean\n",
-    " * Quadratic speedup\n",
-    "\n",
-    "# Exercises\n",
-    " * [Jupyter notebook with tutorial](exercises/w6_01.ipynb): implementing Grover's Algorithm and solving a SAT problem of dimension 3, using local and remote (IBMQ) quantum devices\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index cca3f2df7..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Week 6 - Quantum Search (Grover's Algorithm)
-
- * The Search Problem
- * SAT Problem
- * Grover's Algorithm Overview
- * Phase Inversion
- * Inversion about the Mean
- * Quadratic speedup
-
-# Exercises
- * [Jupyter notebook with tutorial](exercises/w6_01.ipynb): implementing Grover's Algorithm and solving a SAT problem of dimension 3, using local and remote (IBMQ) quantum devices
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 18c4c6c76..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * [Jupyter notebook with tutorial](w6_01.ipynb): implementing Grover's Algorithm and solving a SAT problem of dimension 3, using local and remote (IBMQ) quantum devices\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/w6_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_6-Quantum_Search/exercises/w6_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 918b5d4ab..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,55 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 7 - Quantum Factorization (Shor's Algorithm)\n",
-    "\n",
-    " * The Prime Factorization Problem\n",
-    " * Cryptography Considerations\n",
-    " * Grover's Algorithm Overview\n",
-    " * Shor's Algorithm\n",
-    " * From Factorization to Period Finding\n",
-    " * Quantum Fourier Transform\n",
-    " * From Period to Factors\n",
-    "\n",
-    "# Exercises\n",
-    " * [Jupyter notebook 1 with tutorial](exercises/w7_01.ipynb): understanding the Quantum Fourier Transform on its own (this one is optional as it is very math-heavy for some students)\n",
-    " * [Jupyter notebook 2 with tutorial](exercises/w7_02.ipynb): understanding Shor's Algorithm step by step\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 79d8c6cec..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Week 7 - Quantum Factorization (Shor's Algorithm)
-
- * The Prime Factorization Problem
- * Cryptography Considerations
- * Grover's Algorithm Overview
- * Shor's Algorithm
- * From Factorization to Period Finding
- * Quantum Fourier Transform
- * From Period to Factors
-
-# Exercises
- * [Jupyter notebook 1 with tutorial](exercises/w7_01.ipynb): understanding the Quantum Fourier Transform on its own (this one is optional as it is very math-heavy for some students)
- * [Jupyter notebook 2 with tutorial](exercises/w7_02.ipynb): understanding Shor's Algorithm step by step
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index dd5c4ea95..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * [Jupyter notebook 1 with tutorial](w7_01.ipynb): understanding the Quantum Fourier Transform on its own (this one is optional as it is very math-heavy for some students)\n",
-    " * [Jupyter notebook 2 with tutorial](w7_02.ipynb): understanding Shor's Algorithm step by step\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/w7_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/w7_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/w7_02.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_7-Quantum_Factorization/exercises/w7_02.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 265d84712..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,58 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 8 - High Level Quantum Programming (qiskit-aqua)\n",
-    "\n",
-    " * Qiskit Aqua\n",
-    " * Quantum Supremacy\n",
-    " * Troubleshooting Qiskit Aqua\n",
-    " * High Level Grover's algorithm\n",
-    " * AI problems with aqua\n",
-    " * Optimization problems with aqua (MaxCut, Traveling Salesman)\n",
-    " * Chemistry with aqua\n",
-    "\n",
-    "# Exercises\n",
-    " * [Jupyter notebook 1 with tutorial](exercises/w8_01.ipynb): Grover's algorithm (High Level Quantum)\n",
-    " * [Jupyter notebook 2 with tutorial](exercises/w8_02.ipynb): Support Vector Machine for classification of Breast Cancer datapoints (AI)\n",
-    " * [Jupyter notebook 3 with tutorial](exercises/w8_03.ipynb): Maximum Cut problem (Optimization)\n",
-    " * [Jupyter notebook 4 with tutorial](exercises/w8_04.ipynb): Traveling Salesman problem (Optimization)\n",
-    " * [Jupyter notebook 5 with tutorial](exercises/w8_05.ipynb): Ground state oh H2 Molecule (Chemistry)\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 997bb7b80..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Week 8 - High Level Quantum Programming (qiskit-aqua)
-
- * Qiskit Aqua
- * Quantum Supremacy
- * Troubleshooting Qiskit Aqua
- * High Level Grover's algorithm
- * AI problems with aqua
- * Optimization problems with aqua (MaxCut, Traveling Salesman)
- * Chemistry with aqua
-
-# Exercises
- * [Jupyter notebook 1 with tutorial](exercises/w8_01.ipynb): Grover's algorithm (High Level Quantum)
- * [Jupyter notebook 2 with tutorial](exercises/w8_02.ipynb): Support Vector Machine for classification of Breast Cancer datapoints (AI)
- * [Jupyter notebook 3 with tutorial](exercises/w8_03.ipynb): Maximum Cut problem (Optimization)
- * [Jupyter notebook 4 with tutorial](exercises/w8_04.ipynb): Traveling Salesman problem (Optimization)
- * [Jupyter notebook 5 with tutorial](exercises/w8_05.ipynb): Ground state oh H2 Molecule (Chemistry)
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 6c7a5f67f..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,44 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exercises\n",
-    " * [Jupyter notebook 1 with tutorial](w8_01.ipynb): Grover's algorithm (High Level Quantum)\n",
-    " * [Jupyter notebook 2 with tutorial](w8_02.ipynb): Support Vector Machine for classification of Breast Cancer datapoints (AI)\n",
-    " * [Jupyter notebook 3 with tutorial](w8_03.ipynb): Maximum Cut problem (Optimization)\n",
-    " * [Jupyter notebook 4 with tutorial](w8_04.ipynb): Traveling Salesman problem (Optimization)\n",
-    " * [Jupyter notebook 5 with tutorial](w8_05.ipynb): Ground state oh H2 Molecule (Chemistry)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_01.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_01.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_02.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_02.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_03.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_03.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_04.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_04.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_05.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_8-High_Level_Quantum_Programming/exercises/w8_05.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.ipynb
deleted file mode 100755
index 9a4ad49d6..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.ipynb
+++ /dev/null
@@ -1,55 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Week 9 - State of the Quantum Art\n",
-    "\n",
-    " * Models of Quantum Computation\n",
-    "    * Quantum Circuit\n",
-    "    * Adiabatic Quantum Computation\n",
-    "    * Measurement Based Quantum Computer\n",
-    "    * Topological Quantum Computer\n",
-    " * Building Quantum Computers\n",
-    "    * Implementing a Qubit\n",
-    "    * Quantum Decoherence\n",
-    "    * Quantum Error Correction\n",
-    " * Industrial Standpoint - Race for Quantum\n",
-    " * Closing Remarks\n",
-    "\n",
-    "## Resources\n",
-    " * [PDF slides](slides.pdf)\n",
-    " * [slides src](latex/main.tex) Latex files and image resources used in the presentation (useful for PR on slide typos and such)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.md b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100755
index 224942fb4..000000000
--- a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Week 9 - State of the Quantum Art
-
- * Models of Quantum Computation
-    * Quantum Circuit
-    * Adiabatic Quantum Computation
-    * Measurement Based Quantum Computer
-    * Topological Quantum Computer
- * Building Quantum Computers
-    * Implementing a Qubit
-    * Quantum Decoherence
-    * Quantum Error Correction
- * Industrial Standpoint - Race for Quantum
- * Closing Remarks
-
-## Resources
- * [PDF slides](slides.pdf)
- * [slides src](latex/) Latex files and image resources used in the presentation (useful for PR on slide typos and such)
diff --git a/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/README.ipynb b/community/awards/teach_me_quantum_2018/TeachMeQ/Week_9-State_of_the_Quantum_Art/README.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/basic_intro2qc/QuantumComputingIntroduction.ipynb b/community/awards/teach_me_quantum_2018/basic_intro2qc/QuantumComputingIntroduction.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/.ipynb_checkpoints/B88_Grovers_Search_Solutions-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/.ipynb_checkpoints/B88_Grovers_Search_Solutions-checkpoint.ipynb
deleted file mode 100755
index ad8e00410..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/.ipynb_checkpoints/B88_Grovers_Search_Solutions-checkpoint.ipynb
+++ /dev/null
@@ -1,793 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 10, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> <font color=\"blue\"> Solutions for </font>Grover's Search</h2>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"task1\"></a>\n",
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "Design a quantum circuit with 4 qubits.\n",
-    "\n",
-    "Apply Hadamard to each qubit.\n",
-    "\n",
-    "Execute your circuit 1600 times.\n",
-    "\n",
-    "You should observe each basis state around 100 times.\n",
-    "\n",
-    "Reexecute your circuit 16000 times."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Solution </h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "qreg = QuantumRegister(4) # quantum register with 4 qubits\n",
-    "creg = ClassicalRegister(4) # classical register with 4 bits\n",
-    "mycircuit = QuantumCircuit(qreg,creg) # quantum circuit with quantum and classical registers\n",
-    "\n",
-    "# apply h-gate (Hadamard) to each qubit\n",
-    "for i in range(4):\n",
-    "    mycircuit.h(qreg[i])\n",
-    "\n",
-    "# measure both qubits\n",
-    "mycircuit.measure(qreg,creg)\n",
-    "    \n",
-    "# execute the circuit 1600 times, and print the outcomes\n",
-    "job = execute(mycircuit,Aer.get_backend('qasm_simulator'),shots=1600)\n",
-    "counts = job.result().get_counts(mycircuit)\n",
-    "for outcome in counts:\n",
-    "    reverse_outcome = ''\n",
-    "    for i in outcome:\n",
-    "        reverse_outcome = i + reverse_outcome\n",
-    "    print(reverse_outcome,\"is observed\",counts[outcome],\"times\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"task2\"></a>\n",
-    "<h3> Task 2: Emulating Grover's search </h3>\n",
-    "\n",
-    "For this task, you can use the methods given in notebook <a href=\"B80_Reflections.ipynb\" target=\"_blank\">B80_Reflections</a>.\n",
-    "\n",
-    "Set the value of $ k $ to 4. Then, the size of list is $ 2^k = 16 $.\n",
-    "\n",
-    "Pick the value of $ m $ as 3, the number of the marked elements.\n",
-    "\n",
-    "As described above, $ \\ket{u} = \\sqrt{\\frac{3}{16}} \\ket{u_{marked}} + \\sqrt{\\frac{13}{16}} \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "Create a quantum circuit with single qubit.\n",
-    "\n",
-    "States $ \\ket{1} $ and $ \\ket{0} $ represents the quantum state $ \\ket{u_{marked}} $ and $ \\ket{u_{unmarked}}$, respectively.\n",
-    "\n",
-    "Then, $ \\ket{u} = \\sqrt{\\frac{13}{16}} \\ket{0} + \\sqrt{\\frac{3}{16}} \\ket{1} $.\n",
-    "\n",
-    "<b>Determine the angle $ \\theta $, the angle between $ \\ket{u} $ and $ \\ket{0} $.</b>\n",
-    "\n",
-    "<b>Iterate Grover's search algorithm once by using your quantum circuit.</b>\n",
-    "\n",
-    "For each reflection, use ry-gate (rotation).\n",
-    "<ul>\n",
-    "    <li> Define a list to store all quantum states (with their labels) that will be visited.</li>\n",
-    "    <li> Implement the first reflection on your qubit </li>\n",
-    "    <li> Read the current quantum state and store it on your list </li>\n",
-    "    <li> Implement the second reflection on your qubit </li>\n",
-    "    <li> Read the current quantum state and store it on your list\n",
-    "    <li> Draw all visited quantum states with their labels </li>\n",
-    "    <li> Execute your circuit 100 times </li>\n",
-    "</ul>\n",
-    "\n",
-    "Is this single iteration enough to observe state $ \\ket{1} $ more than state $ \\ket{0} $? "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Solution </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Find angle theta ($\\theta$)</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# find the angle theta\n",
-    "\n",
-    "u2 = [(13/16)**0.5,(3/16)**0.5]\n",
-    "print(u2)\n",
-    "\n",
-    "from math import acos # acos is the inverse of function cosine\n",
-    "from math import pi \n",
-    "\n",
-    "def angle_between_two_quantum_states(quantum_state1,quantum_state2):\n",
-    "    inner_product = quantum_state1[0] * quantum_state2[0] + quantum_state1[1] * quantum_state2[1]\n",
-    "    return acos(inner_product) \n",
-    "\n",
-    "# angle between |u> and |0> \n",
-    "theta2 = angle_between_two_quantum_states(u2,[1,0])\n",
-    "print(theta2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>The previously used functions</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# COPY-PASTE the functions from the notebook \"B80_Reflections\"\n",
-    "\n",
-    "def amplitudes_of_a_quantum_state(quantum_circuit):\n",
-    "    # import all necessary objects and methods for quantum circuits\n",
-    "    from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "    \n",
-    "     # the following code is used to get the quantum state of a quantum circuit\n",
-    "    job = execute(quantum_circuit,Aer.get_backend('statevector_simulator'))\n",
-    "    current_quantum_state=job.result().get_statevector(quantum_circuit) \n",
-    "    \n",
-    "    # now we read the real parts of the amplitudes\n",
-    "    the_first_amplitude = current_quantum_state[0].real # amplitude of |0>\n",
-    "    the_second_amplitude = current_quantum_state[1].real # amplitude of |1>\n",
-    "    \n",
-    "    return[the_first_amplitude,the_second_amplitude]\n",
-    "# end of function\n",
-    "\n",
-    "def visualize_quantum_states(quantum_states):\n",
-    "    # import the useful tool for drawing figures in pythpn\n",
-    "    from matplotlib.pyplot import plot, show, figure, Circle, axis, gca, annotate, arrow, text\n",
-    "    # import the constant pi\n",
-    "    from math import pi\n",
-    "    \n",
-    "    figure(figsize=(6,6), dpi=80) # size of the figure\n",
-    "    gca().add_patch( Circle((0,0),1,color='black',fill=False) ) # draw the circle\n",
-    "    # auxiliary points\n",
-    "    plot(-1.3,0)\n",
-    "    plot(1.3,0)\n",
-    "    plot(0,1.3)\n",
-    "    plot(0,-1.3)\n",
-    "    # axes\n",
-    "    arrow(0,0,1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,-1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,-1.1,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,1.1,head_width=0.04, head_length=0.08)\n",
-    "    \n",
-    "    # draw all quantum states\n",
-    "\n",
-    "    for quantum_state in quantum_states:\n",
-    "        # show the quantum state as an arrow on the diagram\n",
-    "        state_name = quantum_state[0] # label of the quantum state \n",
-    "        x_value = quantum_state[1] # amplitude of |0>\n",
-    "        y_value = quantum_state[2] # amplitude of |1>\n",
-    "        # draw the arrow\n",
-    "        arrow(0,0,x_value,y_value,head_width=0.04, head_length=0.04,color='blue')\n",
-    "\n",
-    "         # the following code is used to write the name of quantum states\n",
-    "        if x_value<0: text_x_value=x_value-0.1\n",
-    "        else: text_x_value=x_value+0.05\n",
-    "        if y_value<0: text_y_value=y_value-0.1\n",
-    "        else: text_y_value=y_value+0.05       \n",
-    "        text(text_x_value,text_y_value,state_name)\n",
-    "\n",
-    "    show() # show the diagram\n",
-    "# end of function"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> One iteration of Grover's search algorithm </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "\n",
-    "all_visited_quantum_states2 =[]\n",
-    "\n",
-    "\n",
-    "qreg2 = QuantumRegister(1) # quantum register with 1 qubit\n",
-    "creg2 = ClassicalRegister(1) # classical register with 1 bit\n",
-    "mycircuit2 = QuantumCircuit(qreg2,creg2) # quantum circuit with quantum and classical registers\n",
-    "\n",
-    "\n",
-    "# set the qubit to |u>\n",
-    "# rotate by theta2\n",
-    "# do not forget to multiply it by 2\n",
-    "mycircuit2.ry(2*theta2,qreg2[0])\n",
-    "\n",
-    "# read and store the current quantum state\n",
-    "[x,y] = amplitudes_of_a_quantum_state(mycircuit2)\n",
-    "all_visited_quantum_states2.append(['u',x,y])\n",
-    "\n",
-    "\n",
-    "# this is (-2*theta2) in the first iteration\n",
-    "rotation_angle_for_the_first_reflection2 = -2 * theta2\n",
-    "# this is always (2*theta2) more than (-1*rotation_angle_for_the_first_reflection2)\n",
-    "rotation_angle_for_the_second_reflection2 = (2*theta2) + (-1*rotation_angle_for_the_first_reflection2)\n",
-    "\n",
-    "# the first reflection: rotate by rotation_angle_for_the_first_reflection2\n",
-    "mycircuit2.ry(2*rotation_angle_for_the_first_reflection2,qreg2[0])\n",
-    "# read and store the current quantum state\n",
-    "[x,y] = amplitudes_of_a_quantum_state(mycircuit2)\n",
-    "all_visited_quantum_states2.append(['r',x,y]) # the label is r (reflected state)\n",
-    "\n",
-    "# the second reflection: rotate by rotation_angle_for_the_second_reflection2\n",
-    "mycircuit2.ry(2*rotation_angle_for_the_second_reflection2,qreg2[0])\n",
-    "# read and store the current quantum state\n",
-    "[x,y] = amplitudes_of_a_quantum_state(mycircuit2)\n",
-    "all_visited_quantum_states2.append(['n',x,y]) # the label is n (new state)\n",
-    "    \n",
-    "    \n",
-    "visualize_quantum_states(all_visited_quantum_states2)\n",
-    "    \n",
-    "    \n",
-    "# measure both qubits\n",
-    "mycircuit2.measure(qreg2,creg2)\n",
-    "    \n",
-    "    \n",
-    "# execute the circuit 100 times, and print the outcomes\n",
-    "job = execute(mycircuit2,Aer.get_backend('qasm_simulator'),shots=100)\n",
-    "counts2 = job.result().get_counts(mycircuit2)\n",
-    "for outcome in counts2:\n",
-    "    reverse_outcome = ''\n",
-    "    for i in outcome:\n",
-    "        reverse_outcome = i + reverse_outcome\n",
-    "    print(reverse_outcome,\"is observed\",counts2[outcome],\"times\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(all_visited_quantum_states2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>\n",
-    "<a id=\"task3\"></a>\n",
-    "<h3> Taks 3 </h3>\n",
-    "\n",
-    "For this task, you can use the methods given in notebook <a href=\"B80_Reflections.ipynb\" target=\"_blank\"> B80_Reflections </a>.\n",
-    "\n",
-    "Set the value of $ k $ to 6. Then, the size of list is $ 2^k = 64 $.\n",
-    "\n",
-    "Pick the value of $ m $ as 1, the number of the marked elements.\n",
-    "\n",
-    "As described above, $ \\ket{u} = \\sqrt{\\frac{1}{64}} \\ket{u_{marked}} + \\sqrt{\\frac{63}{64}} \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "Create a quantum circuit with single qubit.\n",
-    "\n",
-    "States $ \\ket{1} $ and $ \\ket{0} $ represents the quantum state $ \\ket{u_{marked}} $ and $ \\ket{u_{unmarked}}$, respectively.\n",
-    "\n",
-    "Then, $ \\ket{u} = \\sqrt{\\frac{63}{64}} \\ket{0} + \\sqrt{\\frac{1}{64}} \\ket{1} $.\n",
-    "\n",
-    "<b>Determine the angle $ \\theta $, the angle between $ \\ket{u} $ and $ \\ket{0} $.</b>\n",
-    "\n",
-    "<b>Iterate Grover's search algorithm <u>three times</u> by using your quantum circuit.</b>\n",
-    "\n",
-    "For each reflection, use ry-gate (rotation).\n",
-    "<ul>\n",
-    "    <li> Define a list to store all quantum states (with their labels) that will be visited.</li>\n",
-    "    <li> Iterate 3 times:\n",
-    "        <ul>\n",
-    "            <li> Implement the first reflection on your qubit </li>\n",
-    "            <li> Read the current quantum state and store it on your list </li>\n",
-    "            <li> Implement the second reflection on your qubit </li>\n",
-    "            <li> Read the current quantum state and store it on your list</li>\n",
-    "        </ul> </li>\n",
-    "    <li> Draw all visited quantum states with their labels </li>\n",
-    "    <li> Execute your circuit 100 times </li>\n",
-    "</ul>\n",
-    "\n",
-    "Is 3 iterations enough to observe state $ \\ket{1} $ more than state $ \\ket{0} $?\n",
-    "\n",
-    "Try 4, 5, 6, 7, 8, 9, and 10 iterations.\n",
-    "\n",
-    "What is the best iteration number?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Solution </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Find angle theta ($\\theta$)</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# find the angle theta\n",
-    "\n",
-    "u3 = [(63/64)**0.5,(1/64)**0.5]\n",
-    "print(u3)\n",
-    "\n",
-    "from math import acos # acos is the inverse of function cosine\n",
-    "from math import pi \n",
-    "\n",
-    "def angle_between_two_quantum_states(quantum_state1,quantum_state2):\n",
-    "    inner_product = quantum_state1[0] * quantum_state2[0] + quantum_state1[1] * quantum_state2[1]\n",
-    "    return acos(inner_product) \n",
-    "\n",
-    "# angle between |u> and |0> \n",
-    "theta3 = angle_between_two_quantum_states(u3,[1,0])\n",
-    "print(theta3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>The previously used functions</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# COPY-PASTE the functions from the notebook \"B80_Reflections\"\n",
-    "\n",
-    "def amplitudes_of_a_quantum_state(quantum_circuit):\n",
-    "    # import all necessary objects and methods for quantum circuits\n",
-    "    from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "    \n",
-    "     # the following code is used to get the quantum state of a quantum circuit\n",
-    "    job = execute(quantum_circuit,Aer.get_backend('statevector_simulator'))\n",
-    "    current_quantum_state=job.result().get_statevector(quantum_circuit) \n",
-    "    \n",
-    "    # now we read the real parts of the amplitudes\n",
-    "    the_first_amplitude = current_quantum_state[0].real # amplitude of |0>\n",
-    "    the_second_amplitude = current_quantum_state[1].real # amplitude of |1>\n",
-    "    \n",
-    "    return[the_first_amplitude,the_second_amplitude]\n",
-    "# end of function\n",
-    "\n",
-    "def visualize_quantum_states(quantum_states):\n",
-    "    # import the useful tool for drawing figures in pythpn\n",
-    "    from matplotlib.pyplot import plot, show, figure, Circle, axis, gca, annotate, arrow, text\n",
-    "    # import the constant pi\n",
-    "    from math import pi\n",
-    "    \n",
-    "    figure(figsize=(6,6), dpi=80) # size of the figure\n",
-    "    gca().add_patch( Circle((0,0),1,color='black',fill=False) ) # draw the circle\n",
-    "    # auxiliary points\n",
-    "    plot(-1.3,0)\n",
-    "    plot(1.3,0)\n",
-    "    plot(0,1.3)\n",
-    "    plot(0,-1.3)\n",
-    "    # axes\n",
-    "    arrow(0,0,1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,-1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,-1.1,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,1.1,head_width=0.04, head_length=0.08)\n",
-    "    \n",
-    "    # draw all quantum states\n",
-    "\n",
-    "    for quantum_state in quantum_states:\n",
-    "        # show the quantum state as an arrow on the diagram\n",
-    "        state_name = quantum_state[0] # label of the quantum state \n",
-    "        x_value = quantum_state[1] # amplitude of |0>\n",
-    "        y_value = quantum_state[2] # amplitude of |1>\n",
-    "        # draw the arrow\n",
-    "        arrow(0,0,x_value,y_value,head_width=0.04, head_length=0.04,color='blue')\n",
-    "\n",
-    "         # the following code is used to write the name of quantum states\n",
-    "        if x_value<0: text_x_value=x_value-0.1\n",
-    "        else: text_x_value=x_value+0.05\n",
-    "        if y_value<0: text_y_value=y_value-0.1\n",
-    "        else: text_y_value=y_value+0.05       \n",
-    "        text(text_x_value,text_y_value,state_name)\n",
-    "\n",
-    "    show() # show the diagram\n",
-    "# end of function"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Five iterations of Grover's search algorithm </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "\n",
-    "all_visited_quantum_states3 =[]\n",
-    "\n",
-    "\n",
-    "qreg3 = QuantumRegister(1) # quantum register with 1 qubit\n",
-    "creg3 = ClassicalRegister(1) # classical register with 1 bit\n",
-    "mycircuit3 = QuantumCircuit(qreg3,creg3) # quantum circuit with quantum and classical registers\n",
-    "\n",
-    "# set the qubit to |u>\n",
-    "# rotate by theta3\n",
-    "# do not forget to multiply it by 2\n",
-    "mycircuit3.ry(2*theta3,qreg3[0])\n",
-    "\n",
-    "# read and store the current quantum state\n",
-    "[x,y] = amplitudes_of_a_quantum_state(mycircuit3)\n",
-    "all_visited_quantum_states3.append(['u',x,y])\n",
-    "\n",
-    "# this is -2 * theta3 in the first iteration\n",
-    "rotation_angle_for_the_first_reflection3 = -2 * theta3\n",
-    "# this is always (2*theta3) more than (-1*rotation_angle_for_the_first_reflection3)\n",
-    "rotation_angle_for_the_second_reflection3 = (2*theta3) + (-1*rotation_angle_for_the_first_reflection3)\n",
-    "\n",
-    "for i in range(3): # three iterations # later check 4, 5, 6, 7, 8, 9, and 10\n",
-    "\n",
-    "    # the first reflection: rotate by rotation_angle_for_the_first_reflection3\n",
-    "    mycircuit3.ry(2*rotation_angle_for_the_first_reflection3,qreg3[0])\n",
-    "    # read and store the current quantum state\n",
-    "    [x,y] = amplitudes_of_a_quantum_state(mycircuit3)\n",
-    "    all_visited_quantum_states3.append(['r'+str(i+1),x,y]) # the labels are r1, r2, ... (reflected states)\n",
-    "\n",
-    "    # the second reflection: rotate by rotation_angle_for_the_second_reflection3\n",
-    "    mycircuit3.ry(2*rotation_angle_for_the_second_reflection3,qreg3[0])\n",
-    "    # read and store the current quantum state\n",
-    "    [x,y] = amplitudes_of_a_quantum_state(mycircuit3)\n",
-    "    all_visited_quantum_states3.append(['n'+str(i+1),x,y]) # the labels are n1, n2, ... (new states)\n",
-    "    \n",
-    "    # this will be increased by (-4*theta2) after each iteration\n",
-    "    rotation_angle_for_the_first_reflection3 = rotation_angle_for_the_first_reflection3 -4* theta3\n",
-    "    # this is always (2*theta2) more than (-1*rotation_angle_for_the_first_reflection3)\n",
-    "    rotation_angle_for_the_second_reflection3 = (2*theta3) + (-1*rotation_angle_for_the_first_reflection3)\n",
-    "# end of iterations\n",
-    "\n",
-    "visualize_quantum_states(all_visited_quantum_states3)\n",
-    "    \n",
-    "# measure both qubits\n",
-    "mycircuit3.measure(qreg3,creg3)\n",
-    "    \n",
-    "# execute the circuit 100 times, and print the outcomes\n",
-    "job = execute(mycircuit3,Aer.get_backend('qasm_simulator'),shots=100)\n",
-    "counts3 = job.result().get_counts(mycircuit3)\n",
-    "for outcome in counts3:\n",
-    "    reverse_outcome = ''\n",
-    "    for i in outcome:\n",
-    "        reverse_outcome = i + reverse_outcome\n",
-    "    print(reverse_outcome,\"is observed\",counts3[outcome],\"times\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(all_visited_quantum_states3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>\n",
-    "<a id=\"task4\"></a>\n",
-    "<h3> Task 4 </h3>\n",
-    "\n",
-    "Repeat Task 3 for $ k = 8 $ and $ m = 1 $, but algorithmically find the best iteration number, say $B$. \n",
-    "\n",
-    "You may execute your circuit 1000 times to have more reliable results.\n",
-    "<hr>\n",
-    "<i> Hint:\n",
-    "\n",
-    "For each iteration number, you may check how many times the state $ \\ket{1} $ is observed. \n",
-    "<br><br>\n",
-    "This value should be at least 500.\n",
-    "\n",
-    "And, when this value starts to decrease, you may announce the previous iteration number as the best. \n",
-    "</i>\n",
-    "<hr>\n",
-    "Our solution outputs $ B $ as 12 in every execution."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Solution </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Find angle theta ($\\theta$)</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# find the angle theta\n",
-    "# k=8, 2^k = 256\n",
-    "\n",
-    "u4 = [(255/256)**0.5,(1/256)**0.5]\n",
-    "print(u4)\n",
-    "\n",
-    "from math import acos # acos is the inverse of function cosine\n",
-    "from math import pi \n",
-    "\n",
-    "def angle_between_two_quantum_states(quantum_state1,quantum_state2):\n",
-    "    inner_product = quantum_state1[0] * quantum_state2[0] + quantum_state1[1] * quantum_state2[1]\n",
-    "    return acos(inner_product) \n",
-    "\n",
-    "# angle between |u> and |0> \n",
-    "theta4 = angle_between_two_quantum_states(u4,[1,0])\n",
-    "print(theta4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>The previously used functions</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# COPY-PASTE the functions from the notebook \"B80_Reflections\"\n",
-    "\n",
-    "def amplitudes_of_a_quantum_state(quantum_circuit):\n",
-    "    # import all necessary objects and methods for quantum circuits\n",
-    "    from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "    \n",
-    "     # the following code is used to get the quantum state of a quantum circuit\n",
-    "    job = execute(quantum_circuit,Aer.get_backend('statevector_simulator'))\n",
-    "    current_quantum_state=job.result().get_statevector(quantum_circuit) \n",
-    "    \n",
-    "    # now we read the real parts of the amplitudes\n",
-    "    the_first_amplitude = current_quantum_state[0].real # amplitude of |0>\n",
-    "    the_second_amplitude = current_quantum_state[1].real # amplitude of |1>\n",
-    "    \n",
-    "    return[the_first_amplitude,the_second_amplitude]\n",
-    "# end of function\n",
-    "\n",
-    "def visualize_quantum_states(quantum_states):\n",
-    "    # import the useful tool for drawing figures in pythpn\n",
-    "    from matplotlib.pyplot import plot, show, figure, Circle, axis, gca, annotate, arrow, text\n",
-    "    # import the constant pi\n",
-    "    from math import pi\n",
-    "    \n",
-    "    figure(figsize=(6,6), dpi=80) # size of the figure\n",
-    "    gca().add_patch( Circle((0,0),1,color='black',fill=False) ) # draw the circle\n",
-    "    # auxiliary points\n",
-    "    plot(-1.3,0)\n",
-    "    plot(1.3,0)\n",
-    "    plot(0,1.3)\n",
-    "    plot(0,-1.3)\n",
-    "    # axes\n",
-    "    arrow(0,0,1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,-1.1,0,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,-1.1,head_width=0.04, head_length=0.08)\n",
-    "    arrow(0,0,0,1.1,head_width=0.04, head_length=0.08)\n",
-    "    \n",
-    "    # draw all quantum states\n",
-    "\n",
-    "    for quantum_state in quantum_states:\n",
-    "        # show the quantum state as an arrow on the diagram\n",
-    "        state_name = quantum_state[0] # label of the quantum state \n",
-    "        x_value = quantum_state[1] # amplitude of |0>\n",
-    "        y_value = quantum_state[2] # amplitude of |1>\n",
-    "        # draw the arrow\n",
-    "        arrow(0,0,x_value,y_value,head_width=0.04, head_length=0.04,color='blue')\n",
-    "\n",
-    "         # the following code is used to write the name of quantum states\n",
-    "        if x_value<0: text_x_value=x_value-0.1\n",
-    "        else: text_x_value=x_value+0.05\n",
-    "        if y_value<0: text_y_value=y_value-0.1\n",
-    "        else: text_y_value=y_value+0.05       \n",
-    "        text(text_x_value,text_y_value,state_name)\n",
-    "\n",
-    "    show() # show the diagram\n",
-    "# end of function"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Five iterations of Grover's search algorithm </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "\n",
-    "how_many_times_state_one_observed = 0\n",
-    "\n",
-    "decrease = False\n",
-    "\n",
-    "number_of_iteration = 1\n",
-    "\n",
-    "while decrease == False:\n",
-    "\n",
-    "    qreg4 = QuantumRegister(1) # quantum register with 1 qubit\n",
-    "    creg4 = ClassicalRegister(1) # classical register with 1 bit\n",
-    "    mycircuit4 = QuantumCircuit(qreg4,creg4) # quantum circuit with quantum and classical registers\n",
-    "\n",
-    "    # set the qubit to |u>\n",
-    "    # rotate by theta4\n",
-    "    # do not forget to multiply it by 2\n",
-    "    mycircuit4.ry(2*theta4,qreg4[0])\n",
-    "\n",
-    "\n",
-    "    # this is -2 * theta4 in the first iteration\n",
-    "    rotation_angle_for_the_first_reflection4 = -2 * theta4\n",
-    "    # this is always (2*theta4) more than (-1*rotation_angle_for_the_first_reflection4)\n",
-    "    rotation_angle_for_the_second_reflection4 = (2*theta4) + (-1*rotation_angle_for_the_first_reflection4)\n",
-    "\n",
-    "    for i in range(number_of_iteration):\n",
-    "        \n",
-    "        # the first reflection: rotate by rotation_angle_for_the_first_reflection4\n",
-    "        mycircuit4.ry(2*rotation_angle_for_the_first_reflection4,qreg4[0])\n",
-    "\n",
-    "        # the second reflection: rotate by rotation_angle_for_the_second_reflcetion4\n",
-    "        mycircuit4.ry(2*rotation_angle_for_the_second_reflection4,qreg4[0])\n",
-    "    \n",
-    "        # this will be increased by (-4*theta4) after each iteration\n",
-    "        rotation_angle_for_the_first_reflection4 = rotation_angle_for_the_first_reflection4 -4* theta4\n",
-    "        # this is always (2*theta4) more than (-1*rotation_angle_for_the_first_reflection4)\n",
-    "        rotation_angle_for_the_second_reflection4 = (2*theta4) + (-1*rotation_angle_for_the_first_reflection4)\n",
-    "    # end of iterations\n",
-    "\n",
-    "    \n",
-    "    # measure both qubits\n",
-    "    mycircuit4.measure(qreg4,creg4)\n",
-    "    \n",
-    "    # execute the circuit 1000 times, and print the outcomes\n",
-    "    job = execute(mycircuit4,Aer.get_backend('qasm_simulator'),shots=1000)\n",
-    "    counts4 = job.result().get_counts(mycircuit4)\n",
-    "    print(number_of_iteration,counts4) # print the outcomes\n",
-    "    for outcome in counts4:\n",
-    "        if outcome == '1': \n",
-    "            # how_many_times_state_one_observed is more than 500 and has a less value than the previous one\n",
-    "            # then it is time to STOP\n",
-    "            if how_many_times_state_one_observed> 500 and how_many_times_state_one_observed > counts4[outcome]: \n",
-    "                print(\"B is\",number_of_iteration-1)\n",
-    "                decrease = True\n",
-    "            else: # we should continue\n",
-    "                how_many_times_state_one_observed = counts4[outcome] # update how_many_times_state_one_observed\n",
-    "                number_of_iteration = number_of_iteration + 1 # increase number_of_iteration"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B08_Python_Basics_Variables_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B08_Python_Basics_Variables_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B10_Python_Basics_Loops_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B10_Python_Basics_Loops_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B12_Python_Basics_Conditionals_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B12_Python_Basics_Conditionals_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B14_Python_Basics_Lists_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B14_Python_Basics_Lists_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B16_Python_Lists_Vectors_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B16_Python_Lists_Vectors_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B18_Python_Lists_Inner_Product_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B18_Python_Lists_Inner_Product_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B20_Python_Lists_Matrices_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B20_Python_Lists_Matrices_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B22_Python_Lists_Tensor_Product_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B22_Python_Lists_Tensor_Product_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B24_One_Bit_Solution.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B24_One_Bit_Solution.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B26_Coin_Flip_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B26_Coin_Flip_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B28_Coin_Flip_Game_Solution.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B28_Coin_Flip_Game_Solution.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B32_Probabilistic_States_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B32_Probabilistic_States_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B36_Probabilistic_Operators_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B36_Probabilistic_Operators_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B42_Hadamard_Solution.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B42_Hadamard_Solution.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B46_Quantum_State_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B46_Quantum_State_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B48_Superposition_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B48_Superposition_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B56_Two_Qubits_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B56_Two_Qubits_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B60_Superdense_Coding_Solution.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B60_Superdense_Coding_Solution.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B64_Phase_Kickback_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B64_Phase_Kickback_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B88_Grovers_Search_Solutions.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze-solutions/B88_Grovers_Search_Solutions.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B01_ Acknowledgements-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B01_ Acknowledgements-checkpoint.ipynb
deleted file mode 100755
index 9180dc446..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B01_ Acknowledgements-checkpoint.ipynb	
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> Acknowledgements </h2>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>\n",
-    "<h3>QuSoft@Riga: Bronze</h3>\n",
-    "\n",
-    "<h4><i>\"Your First Step to Quantum Programming\"</i></h4>\n",
-    "\n",
-    "QuSoft Riga has been preparing tutorials to teach programming quantum computers. \n",
-    "\n",
-    "Our first tutorial is Bronze. \n",
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We thank to <b><i>Katrina Kizenbaha</i></b> from Riga TechGirls for her revisions on our notebooks on python.\n",
-    "\n",
-    "We thank to <b><i>Martins Kalis</i></b> (QuSoft@Riga) for his technical comments on python, qiskit, and our notebooks.\n",
-    "\n",
-    "We thank to <b><i>Maksims Dimitrijevs</i></b> (QuSoft@Riga) for his careful reading and corrections on our notebooks.\n",
-    "\n",
-    "We thank to QuSoft members <b><i>Martins Kalis</i></b>, <b><i>Maksims Dimitrijevs</i></b>, <b><i>Aleksejs Naumovs</i></b> <b><i>Andis Draguns</i></b>, and <b><i>Matiss Apinis</i></b>  for their help and support.\n",
-    "\n",
-    "We thank to <b>the students (DF@LU) attending QuSoft's meetings</b> on each Friday (Fall 2018) for their comments while working with our notebooks.\n",
-    "<hr>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B02_cells_in_notebook-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B02_cells_in_notebook-checkpoint.ipynb
deleted file mode 100755
index 8b0c28a7c..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B02_cells_in_notebook-checkpoint.ipynb
+++ /dev/null
@@ -1,144 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# A jupyter notebook is composed by one or more cells.\n",
-    "# A cell is used to write and execute your codes.\n",
-    "# A cell is also used to write descriptions, notes, formulas, etc.\n",
-    "# You can format your descriptions by using HTML or LaTex codes.\n",
-    "# During this tutorial, you are expected to write only python codes.\n",
-    "# Interested readers may also use HTML and LaTex, but it is not necesary to complete this tutorial. \n",
-    "\n",
-    "#\n",
-    "# We explain basic usage of cells in Jupyter notebooks here\n",
-    "#\n",
-    "\n",
-    "# This is the first cell in this notebook.\n",
-    "# You can write Python code here, \n",
-    "# and then EXECUTE/RUN it by\n",
-    "# 1) pressing SHIFT+ENTER\n",
-    "# 2) clicking \"Run\" on the menu\n",
-    "\n",
-    "\n",
-    "# here is a few lines of python codes\n",
-    "\n",
-    "print(\"hello world\")\n",
-    "str=\"*\"\n",
-    "for i in range(5):\n",
-    "    print(str)\n",
-    "    str+=\"*\"\n",
-    "\n",
-    "# after executing this cell, you will see the outcomes immedeately after this cell\n",
-    "#     you may change the range above and re-run this cell\n",
-    "\n",
-    "# after executing this cell, you can continue with the next cell"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is the second cell.\n",
-    "#\n",
-    "# When you double click after the last cell, a new cell appears automatically.\n",
-    "#     It automatically happens when you execute the last cell as well. \n",
-    "#\n",
-    "# By using menu item \"Insert\", you may also add a new cell before or after the selected cell.\n",
-    "#     When a cell is selected, you may delete it by using menu item \"Edit\".\n",
-    "#\n",
-    "# As you may notice, there are other editing options under \"Edit\",\n",
-    "#     for example, copy/cut-paste cells and split-merge cells."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b>This is the third cell.</b> <br>\n",
-    "There are four types of cells. <br>\n",
-    "The first type is called \"Code\", which is the default type, as the above two cells. <br>\n",
-    "This is a second type cell called \"Markdown\", which is used for explanatory texts. <br> \n",
-    "The type of any cell is shown on the toolbar under the menu bar (right-side). You can change the type of a cell from this pulldown menu. <br>\n",
-    "You can also determine the type by clicking on the menu item \"Cell\", and then the subitem \"Cell Type\".<br>\n",
-    "\n",
-    "You can write HTML and LaTex code here.<br>\n",
-    "Here we have very basic HTML codes: making the texts bold, italic, or underline, and inserting line breaks.\n",
-    "\n",
-    "<i>By double clicking on this cell, you can see the code.</i> <br>\n",
-    "<u>By execucting this cell, you see the result text.</u>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> This is the fourth cell.</b>\n",
-    "<br>\n",
-    "Its type is also \"Markdown\".\n",
-    "\n",
-    "LaTex is used to show mathematical expressions, formulas, etc. \n",
-    "\n",
-    "For example, $ x^2 + y ^ 2 = \\frac{4}{9} $, $ \\sum_{i=1}^n (i+2)^{3} $, or $ \\left( \\begin{array}{rr}  1 & 0 & -1 \\\\ 2 & -2 & 0 \\\\ 3 & -1 & -2  \\end{array} \\right) $.\n",
-    "\n",
-    "<i>By double clicking on this cell, you can see the code.</i> <br> \n",
-    "<u>By executing/running this cell, you can see the result text.</u>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Self Practice</h3>\n",
-    "<ol>\n",
-    "    <li> Please insert a new cell between this first and second cells. \n",
-    "        <ul>\n",
-    "            <li> Change its type to \"Markdown\". </li>\n",
-    "            <li> Write down \"This is the 1.5th cell\" and some random text (Hello world, your name and surname, etc.). </li>\n",
-    "            <li> Run it and check the result. </li>\n",
-    "        </ul>\n",
-    "    </li>\n",
-    "    <li> Please insert a new cell between two markdown cells above.\n",
-    "        <ul>\n",
-    "            <li> Write as a comment \"# This is the 3.5th cell\".\n",
-    "            <li> Use it as a \"Code\" cell. (By default, it is a code cell.)</li>\n",
-    "            <li> Write a single line python code, e.g., print(\"hello world :-\")</li>\n",
-    "            <li> Run your code.</li>\n",
-    "        </ul>\n",
-    "    </li>\n",
-    "    <li> Cut the cell having the text \"This is the 1.5th cell\", and insert (paste) it after the cell having the text \"This is the 3.5th cell\". </li>\n",
-    "    <li> Cut these two cells (\"1.5th and 3.5th\") together, and insert (paste) them as the top cells. </li>\n",
-    "    <li> Delete the cell having the text \"This is the 1.5th cell\". </li>\n",
-    "    <li> Reposition the cell having the text \"This is the 3.5th cell\" to its previous place. </li>\n",
-    "</ol>\n",
-    "     "
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B04_hello_from_quantum_world-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B04_hello_from_quantum_world-checkpoint.ipynb
deleted file mode 100755
index 2840b4698..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B04_hello_from_quantum_world-checkpoint.ipynb
+++ /dev/null
@@ -1,535 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 02, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> Hello From Quantum World </h2>\n",
-    "\n",
-    "This is our test file. \n",
-    "\n",
-    "Please run each cell one by one."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Sqaure brackets on the left sides of the code cells </h3>\n",
-    "\n",
-    "<ul>\n",
-    "    <li> Each pair of the brackets shows the execution counter of the cell. </li>\n",
-    "    <li> If the cell has not been executed, the inside of the brackets is empty.</li>\n",
-    "    <li> When the code cell is still running, there appears <u>a single star</u> inside the brackets [*].</li>    \n",
-    "    <li> When the execution is finished, there appears a number inside the brackets [number].</li>\n",
-    "    <li> A cell can be executed many times. Each time it takes a new number (in increasing order). </li>\n",
-    "</ul>\n",
-    "\n",
-    "The execution of a cell may take a few miliseconds, a few seconds, a few minutes, or much longer time.\n",
-    "\n",
-    "<font style=\"color:blue;\"> Therefore, you may not see any outcome until [*] is changed to [number].</font>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Python Test </h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# I am a comment in python\n",
-    "\n",
-    "print(\"Hello From Quantum World :-)\")\n",
-    "\n",
-    "# please run me"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Quantum Circuit Test </h3>\n",
-    "\n",
-    "Our quantum programs are designed as quantum curcits. \n",
-    "\n",
-    "Explanations will appear in the main tutorial.\n",
-    "\n",
-    "<h4>We create a very simple quantum circuit</h4>\n",
-    "\n",
-    "Please run the cell below, and wait until the execution is completed.\n",
-    "\n",
-    "<i>Remark that we call a function or an object from a module in python as\n",
-    "    \n",
-    "<b>from</b> module-name <b>import</b> function-name\n",
-    "    \n",
-    "<b>from</b> module-name <b>import</b> object-name\n",
-    "</i>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from random import randrange\n",
-    "\n",
-    "# Create my circuit and register objects\n",
-    "qreg = QuantumRegister(2) # my quantum register\n",
-    "creg = ClassicalRegister(2) # my classical register \n",
-    "circuit = QuantumCircuit(qreg,creg) # my quantum circuit\n",
-    "\n",
-    "# let's apply a Hadamard gate to the first qubit\n",
-    "\n",
-    "circuit.h(qreg[0])\n",
-    "\n",
-    "# let's set the second qubit to |1>\n",
-    "circuit.x(qreg[1])\n",
-    "\n",
-    "# let's apply CNOT(first_qubit,second_qubit)\n",
-    "circuit.cx(qreg[0],qreg[1])\n",
-    "\n",
-    "# let's measure the both qubits\n",
-    "circuit.measure(qreg,creg)\n",
-    "\n",
-    "print(\"The execution was completed, and the circuit was created :)\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>We execute the circuit (our program) 1024 times in the local simulator</h4>\n",
-    "\n",
-    "Each execution may have a different outcome (?).\n",
-    "\n",
-    "In our simple program, we expect to observe either 01 or 10 as the outcome in a single execution. \n",
-    "\n",
-    "We print the measurement results. \n",
-    "\n",
-    "Thus, we will see how many times '01' is observed and how many times '10' is observed.\n",
-    "\n",
-    "You may execute this cell a few times, and check the outcomes in each case."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## execute the circuit 100 times\n",
-    "job = execute(circuit,Aer.get_backend('qasm_simulator'),shots=1024)\n",
-    "# get the result\n",
-    "counts = job.result().get_counts(circuit)\n",
-    "print(counts)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>Draw the circuit</h4>\n",
-    "\n",
-    "We can draw our circuit.  \n",
-    "\n",
-    "If the circuit does not appear in the first run, please re-run the cell."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "# draw the overall circuit \n",
-    "drawer(circuit)\n",
-    "# re-execute me if you DO NOT see the circuit diagram"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3>IBMQ Test</h3>\n",
-    "\n",
-    "<i> The remaining part requires <u>internet connection</u>.</i>\n",
-    "\n",
-    "We will execute our test circuit on IBM simulator, and then on one of IBM real qauntum computers.\n",
-    "\n",
-    "<font> Please wait the execution of each cell to be completed, before executing the next cell.</font>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Save your API on the disk </h4>\n",
-    "\n",
-    "Please write YOUR IBM API TOKEN in the following cell, and then run the cell.\n",
-    "\n",
-    "(The instruction is given at the end of section \"Testing: First Program\" in the file <a href=\"../bronze-start.html#IBMQ\">bronze-start.html</a>\n",
-    "\n",
-    "Once your YOUR IBM API TOKEN is saved on the disk,  it can be directly used later."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import IBMQ\n",
-    "\n",
-    "IBMQ.save_account('write YOUR IBM API TOKEN here')\n",
-    "\n",
-    "# Then, execute this cell"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> See the stored account(s) </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.stored_accounts()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Load our account(s) </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.load_accounts()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> See the active account(s) </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.active_accounts()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>See available backends</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.backends()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> See the currently operational real quantum computer(s)</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IBMQ.backends(operational=True, simulator=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> See the least busy real quantum computer </h4> "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.backends.ibmq import least_busy\n",
-    "least_busy(IBMQ.backends(simulator=False))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> IBMQ simulator </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Use the simulator as backend </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "backend = least_busy(IBMQ.backends(simulator=True))\n",
-    "\n",
-    "backend.name()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Create a job for the backend </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import compile\n",
-    "\n",
-    "qobj = compile(circuit, backend=backend, shots=1024)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Execute this job on the simulator </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "job = backend.run(qobj)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Check the result </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result = job.result()\n",
-    "counts = result.get_counts()\n",
-    "print(counts)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> IBMQ real quantum computers (Optional) </h3>\n",
-    "\n",
-    "Please read the following  part to see IBM's policy for usage for the prototype real quantum computers. [accessed on October 28, 2018]\n",
-    "<br><br>\n",
-    "<div style=\"background-color:#eeeeee;font-size:15px;\">\n",
-    "    <b>Frequently Asked Questions</b>\n",
-    "<br>\n",
-    "<a href=\"https://quantumexperience.ng.bluemix.net/proxy/tutorial/full-user-guide/000-FAQ/000-Frequently_Asked_Questions.html\" target=\"_blank\">https://quantumexperience.ng.bluemix.net/proxy/tutorial/full-user-guide/000-FAQ/000-Frequently_Asked_Questions.html</a>\n",
-    "\n",
-    "How many experiments can I run?\n",
-    "\n",
-    "You can run as many experiments as you have Units to run; each experiment execution requires between 3 and 5 Units. No Units are required to perform simulations or to recall results of an experiment that was run previously.\n",
-    "\n",
-    "What happens when I run out of Units?\n",
-    "\n",
-    "You can still run simulations or recall the result of the experiments that have been run previously, but you must wait for the Units to replenish, which happens either once your execution has run off the queue, or 24 hours, whichever is greater.\n",
-    "</div>\n",
-    "\n",
-    "<font color=\"blue\">You can check your <b>Units</b> in your <u>IBM Q Experience account</u> (My Account > Advanced).</font> "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Use the least busy real machine as backend </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "backend_real = least_busy(IBMQ.backends(simulator=False))\n",
-    "\n",
-    "backend_real.name()\n",
-    "\n",
-    "backend_real.status()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Execute the same job on a real machine </h4>\n",
-    "\n",
-    "<font style=\"color:red\">Depending on the number of pending jobs, it might take for a while to execute our job on the real machine.</font>\n",
-    "\n",
-    "<u> If you do not have enough Units, you should wait for 24 hours to execute your quantum program on a real machine. </u>\n",
-    "\n",
-    "<i> But, this would not be a problem to complete Bronze, because we use the local simulator for our tasks. </i>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "qobj_real = compile(circuit, backend=backend_real, shots=1024)\n",
-    "\n",
-    "job_real = backend_real.run(qobj_real)\n",
-    "\n",
-    "job_real.queue_position()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Check the result </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result_real = job_real.result()\n",
-    "counts_real = result_real.get_counts()\n",
-    "print(counts_real)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<font style=\"color:blue\"> You may finish this notebook before getting the outcomes, if it seems to take long time.</font>\n",
-    "\n",
-    "You may observe more than two outcomes, different than the simulators. \n",
-    "\n",
-    "The expected outcomes '01' and '10' can still be observed more frequently, but we may also observe the unexpected outcomes '00' and '11'. Because, even after a single operation, the prototype quantum computers introduce some errors."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B06_Python_Quick_Reference-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B06_Python_Quick_Reference-checkpoint.ipynb
deleted file mode 100755
index 51d166c53..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B06_Python_Quick_Reference-checkpoint.ipynb
+++ /dev/null
@@ -1,789 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 09, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> Python: Quick Reference </h2>\n",
-    "<hr>\n",
-    "<ul>\n",
-    "    <li><a href=\"#Variables\">Variables</a></li>\n",
-    "    <li><a href=\"#Arithmetic_operators\">Arithmetic operators</a></li>\n",
-    "    <li><a href=\"#Objects\">Objects</a></li>\n",
-    "    <li><a href=\"#Size_of_an_object\">Size of an object</a></li>    \n",
-    "    <li><a href=\"#Loops\">Loops</a></li>\n",
-    "    <li><a href=\"#Conditionals\">Conditionals</a></li>\n",
-    "    <li><a href=\"#Logical_and_Boolean_operators\">Logical and Boolean operators</a></li>\n",
-    "    <li><a href=\"#Double_list\">Double list</a></li>\n",
-    "    <li><a href=\"#List_operations\">List operations</a></li>\n",
-    "    <li><a href=\"#Functions\">Functions</a></li>\n",
-    "    <li><a href=\"#Random_number\">Random number</a></li>\n",
-    "</ul>\n",
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Variables\"></a>\n",
-    "<h3> Variables </h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "number = 5 # integer\n",
-    "real = -3.4 # float\n",
-    "\n",
-    "name = 'Asja' # string\n",
-    "surname = \"Sarkana\" # string\n",
-    "\n",
-    "boolean1 = True # Boolean \n",
-    "boolean1 = False # Boolean "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Arithmetic_operators\"></a>\n",
-    "<h3> Arithmetic operators </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Basic operators </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = 13\n",
-    "b = 5\n",
-    "print(\"a =\",a)\n",
-    "print(\"b =\",b)\n",
-    "print()\n",
-    "\n",
-    "# basics operators\n",
-    "print(\"a + b =\",a+b)\n",
-    "print(\"a - b =\",a-b)\n",
-    "print(\"a * b =\",a*b)\n",
-    "print(\"a / b =\",a/b)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Integer division and modulus operators </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = 13\n",
-    "b = 5\n",
-    "print(\"a =\",a)\n",
-    "print(\"b =\",b)\n",
-    "print()\n",
-    "\n",
-    "# integer division\n",
-    "print(\"a//b =\",a//b)\n",
-    "\n",
-    "# modulus operator\n",
-    "print(\"a mod b =\",a % b)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Exponent operator</h4>\n",
-    "\n",
-    "number\\*\\*exponent"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "b = 5\n",
-    "print(\"b =\",b)\n",
-    "print()\n",
-    "\n",
-    "print(\"b*b =\",b**2)\n",
-    "print(\"b*b*b =\",b**3)\n",
-    "print(\"sqrt(b)=\",b**0.5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Objects\"></a>\n",
-    "<h3> Objects </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Lists </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# list\n",
-    "mylist = [10,8,6,4,2] \n",
-    "\n",
-    "print(mylist)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Tuple </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# tuple\n",
-    "mytuple=(1,4,5,'Asja') \n",
-    "\n",
-    "print(mytuple)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Dictionary </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# dictionary\n",
-    "mydictionary = {\n",
-    "    'name' : \"Asja\",\n",
-    "    'surname':'Sarkane',\n",
-    "    'age': 23\n",
-    "}\n",
-    "\n",
-    "print(mydictionary)\n",
-    "\n",
-    "print(mydictionary['surname'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>List of the other objects or variables </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# list of the other objects or variables\n",
-    "list_of_other_objects =[\n",
-    "    mylist,\n",
-    "    mytuple,\n",
-    "    3,\n",
-    "    \"Asja\",\n",
-    "    mydictionary\n",
-    "]\n",
-    "\n",
-    "print(list_of_other_objects)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Size_of_an_object\"></a>\n",
-    "<h3> Size of an object </h3>\n",
-    "\n",
-    "We use the method \"len()\" that takes an object as the input."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# length of a string\n",
-    "print(len(\"Asja Sarkane\"))\n",
-    "\n",
-    "# size of a list\n",
-    "print(len([1,2,3,4]))\n",
-    "\n",
-    "# size of a dictionary\n",
-    "mydictionary = { 'name' : \"Asja\", 'surname':'Sarkane', 'age': 23}\n",
-    "print(len(mydictionary))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Loops\"></a>\n",
-    "<h3> Loops </h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> While-loop </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "i = 10\n",
-    "while i>0: # while condition(s):\n",
-    "    print(i)\n",
-    "    i = i - 1   "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> For-loop </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in range(10): # i is in [0,1,...,9]\n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in range(-5,6): # i is in [-5,-4,...,0,...,4,5]\n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in range(0,23,4): # i is in [0,4,8,12,16,20]\n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in [3,8,-5,11]: \n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in \"Sarkane\":\n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# dictionary\n",
-    "mydictionary = {\n",
-    "    'name' : \"Asja\",\n",
-    "    'surname':'Sarkane',\n",
-    "    'age': 23,\n",
-    "}\n",
-    "\n",
-    "for key in mydictionary:\n",
-    "    print(\"key is\",key,\"and its value is\",mydictionary[key])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Conditionals\"></a>\n",
-    "<h3>Conditionals </h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for a in range(4,7):\n",
-    "    \n",
-    "    # if condition(s)\n",
-    "    if a<5: \n",
-    "        print(a,\"is less than 5\")\n",
-    "        \n",
-    "    # elif conditions(s)\n",
-    "    elif a==5: \n",
-    "        print(a,\"is equal to 5\")\n",
-    "        \n",
-    "    # else\n",
-    "    else:\n",
-    "        print(a,\"is greater than 5\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Logical_and_Boolean_operators\"></a>\n",
-    "<h3>Logical and Boolean operators</h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Logical operator \"and\"</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Logical operator \"and\"\n",
-    "i = -3\n",
-    "j = 4\n",
-    "if i<0 and j > 0:  \n",
-    "    print(i,\"is negative AND\",j,\"is positive\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>Logical operator \"or\"</h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Logical operator \"or\"\n",
-    "i = -2\n",
-    "j = 2\n",
-    "if i==2 or j == 2:  \n",
-    "    print(\"i OR j is 2: (\",i,\",\",j,\")\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4>Logical operator \"not\" </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Logical operator \"not\"\n",
-    "i = 3\n",
-    "if not (i==2):\n",
-    "    print(i,\"is NOT equal to 2\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Operator \"equal to\" </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Operator \"equal to\"\n",
-    "i = -1\n",
-    "if i == -1:\n",
-    "    print(i,\"is EQUAL TO -1\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Operator \"not equal to\" </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Operator \"not equal to\"\n",
-    "i = 4\n",
-    "if i != 3:\n",
-    "    print(i,\"is NOT EQUAL TO 3\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Operator \"less than or equal to\" </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Operator \"not equal to\"\n",
-    "i = 2\n",
-    "if i <= 5:\n",
-    "    print(i,\"is LESS THAN OR EQUAL TO 5\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Operator \"greater than or equal to\" </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Operator \"not equal to\"\n",
-    "i = 5\n",
-    "if i >= 1:\n",
-    "    print(i,\"is GREATER THAN OR EQUAL TO 3\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Double_list\"></a>\n",
-    "<h3> Double list </h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "A =[\n",
-    "    [1,2,3],\n",
-    "    [-2,-4,-6],\n",
-    "    [3,6,9]\n",
-    "]\n",
-    "\n",
-    "# print all\n",
-    "print(A)\n",
-    "print()\n",
-    "\n",
-    "# print list by list\n",
-    "for list in A:\n",
-    "    print(list)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"List_operations\"></a>\n",
-    "<h3>List operations</h3>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Concatenation of two lists </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "list1 = [1,2,3]\n",
-    "list2 = [4,5,6]\n",
-    "\n",
-    "#concatenation of two lists\n",
-    "\n",
-    "list3 = list1 + list2\n",
-    "print(list3)\n",
-    "\n",
-    "list4 = list2 + list1\n",
-    "print(list4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Appending a new element </h4>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "list = [0,1,2]\n",
-    "\n",
-    "list.append(3)\n",
-    "print(list)\n",
-    "\n",
-    "list = list + [4]\n",
-    "print(list)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Functions\"></a>\n",
-    "<h3>Functions</h3>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def summation_of_integers(n):\n",
-    "    summation = 0\n",
-    "    for integer in range(n+1):\n",
-    "        summation = summation + integer\n",
-    "    return summation\n",
-    "\n",
-    "print(summation_of_integers(10))\n",
-    "print(summation_of_integers(20))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a id=\"Random_number\"></a>\n",
-    "<h3>Random number</h3>\n",
-    "\n",
-    "We can use method \"randrange()\"."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import randrange\n",
-    "\n",
-    "print(randrange(10),\"is picked randomly between 0 and 9\")\n",
-    "      \n",
-    "print(randrange(-9,10),\"is picked randomly between -9 and 9\")\n",
-    "\n",
-    "print(randrange(0,20,3),\"is picked randomly from the list [0,3,6,9,12,15,18]\")"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B24_One_Bit-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B24_One_Bit-checkpoint.ipynb
deleted file mode 100755
index f95288289..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B24_One_Bit-checkpoint.ipynb
+++ /dev/null
@@ -1,539 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> One Bit </h2>\n",
-    "\n",
-    "In daily life, we use decimal number system. It is also called base-10 system, because we have 10 digits:\n",
-    "\n",
-    "$ 0,~1,~2,~3,~4,~5,~6,~7,~8, \\mbox{ and } 9  $.\n",
-    "\n",
-    "In computer science, on the other hand, the widely used system is binary, which has only two digits:\n",
-    "\n",
-    "$ 0 $ and $ 1 $.\n",
-    "\n",
-    "One bit (or binary digit) is the basic unit of information used in computer science. \n",
-    "\n",
-    "It can also be seen as the smallest \"useful\" memory unit, which has two states named 0 and 1. \n",
-    "\n",
-    "One bit can be in (or store) either 0 or 1."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Four operators </h3>\n",
-    "\n",
-    "How many different operators can be defined on a single bit?\n",
-    "\n",
-    "<i>An operator, depending on the current state of the bit, updates the state of bit (the result may be the same state).</i> \n",
-    "\n",
-    "We can apply four different operators to a single bit:\n",
-    "<ol>\n",
-    "    <li> Identity: $ I(0) = 0 $ and $ I(1) = 1 $ </li>\n",
-    "    <li> Negation: $ NOT(0) = 1 $ and $ NOT(1) = 0 $ </li>\n",
-    "    <li> Constant (Zero): $ ZERO(0) = 0 $ and $ ZERO(1) = 0 $ </li>\n",
-    "    <li> Constant (One): $ ONE(0) = 1 $ and $ ONE(1) = 1 $ </li>\n",
-    "</ol>\n",
-    "The first operator is called IDENTITY, because it does not change the content/value of the bit.\n",
-    "\n",
-    "The second operator is named NOT, bacause it negates (flips) the value of bit. \n",
-    "\n",
-    "<i>Remark that 0 and 1 also refers to Boolean values False and True, respectively, and, False is the negation of True, and True is the negation of False.</i>\n",
-    "\n",
-    "The third (resp., fourth) operator returns a constant value 0 (resp., 1), whatever the input is."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Table representation </h3>\n",
-    "\n",
-    "Let's represent the transition of each operator by a table. \n",
-    "\n",
-    "In each table,\n",
-    "<ul>\n",
-    "    <li> the header (first row) representing the initial values, </li>\n",
-    "    <li> the first column representing the final values, </li>\n",
-    "    <li> we use 1 if there is a transition between two values, and, </li>\n",
-    "    <li> we use 0 if there is no transition between two values. </li>\n",
-    "</ul>\n",
-    "\n",
-    "The table representation of the identity operator is given below:\n",
-    "\n",
-    "$\n",
-    "I = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 1 & 0 \\\\  \\mathbf{1} & 0 & 1  \\end{array}\n",
-    "$\n",
-    "\n",
-    "The values in <b>bold</b> are the initial and final values of the bits. The non-bold values represent the transitions.\n",
-    "<ul>\n",
-    "    <li> The top-left non-bold 1 represents the transtion $ 0 \\rightarrow 0 $. </li>\n",
-    "    <li> The bottom-right non-bold 1 represents the transtion $ 1 \\rightarrow 1 $. </li> \n",
-    "    <li> The top-right non-bold 0 means that there is no transition from 1 to 0. </li>\n",
-    "    <li> The bottom-left non-bold 0 means that there is no transition from 0 to 1. </li>\n",
-    "</ul>\n",
-    "The reader may think the values 0 and 1 representing the transitions as True (On) and False (Off), respectively. \n",
-    "\n",
-    "Similarly, we can represent the other operators as below:\n",
-    "\n",
-    "$\n",
-    "NOT = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 0 & 1 \\\\ \\mathbf{1} & 1 & 0  \\end{array}\n",
-    "~~~~~~~~\n",
-    "ZERO = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 1 & 1 \\\\  \\mathbf{1} & 0 & 0  \\end{array}\n",
-    "~~~~~~~~\n",
-    "ONE = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 0 & 0 \\\\  \\mathbf{1} & 1 & 1  \\end{array}\n",
-    ".\n",
-    "$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "Convience yourself with the correctness of each table."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Reversibility and Irreversibility </h3>\n",
-    "\n",
-    "After applying Identity or NOT operatotor, we can easily determine the initial value by checking the final value. \n",
-    "<ul>\n",
-    "    <li> In the case of Identity operator, we simply say the same value. </li>\n",
-    "    <li> In the case of NOT operator, we simply say the other value, i.e., if the final value is 0 (resp., 1), then we say 1 (resp., 0). </li>\n",
-    "</ul>\n",
-    "\n",
-    "However, we cannot know the initial value by checking the final value after applying ZERO or ONE operator. \n",
-    "\n",
-    "Based on this observation, we can classify the operators into two types: <i>Reversible</i> and <i>Irreversible</i>.\n",
-    "<ul>\n",
-    "    <li> If we can recover the initial value(s) from the final value(s), then the operator is called reversible like Identity and NOT operators. </li>\n",
-    "    <li> If we cannot know the initial value(s) from the final value(s), then the operator is called irreversible like ZERO and ONE operators. </li>\n",
-    "</ul>\n",
-    "\n",
-    "<b> This classification is important, because, as will be seen later, the quantum evolution operators are reversible. </b>\n",
-    "\n",
-    "The identity operator does not have any affect on the computation, and so it is not interesting.\n",
-    "\n",
-    "But we will widely use NOT operator in our quantum algortihms.         "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Our first quantum circuit </h3>\n",
-    "\n",
-    "For our quantum programs, we will design quantum circuits.\n",
-    "\n",
-    "As a warm-up example, here we design a circuit with a single quantum bit.\n",
-    "\n",
-    "We also highlight the details on designing quantum circuits along with our codes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# \n",
-    "# A quantum circuit is composed by quantum and classical bits.\n",
-    "#\n",
-    "\n",
-    "# here are the objects that we use to create a quantum circuit\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n",
-    "\n",
-    "# we use a quantum register to keep our quantum bits.\n",
-    "qreg =  QuantumRegister(1) # in this example we will use a single quantum bit\n",
-    "\n",
-    "# To get an information from a quantum bit, it must be measured. (More details will appear.)\n",
-    "#     The measurement result is stored classically.\n",
-    "#     Therefore, we also use a classical regiser with classical bits\n",
-    "creg = ClassicalRegister(1) # in this example we will use a single classical bit\n",
-    "\n",
-    "# now we can define our quantum circuit\n",
-    "# it is composed by a quantum and a classical register\n",
-    "mycircuit = QuantumCircuit(qreg,creg)\n",
-    "\n",
-    "# we apply operators on quantum bits\n",
-    "# operators are also called as gates\n",
-    "# we apply NOT operator represented as \"x\"\n",
-    "# operator is a part of the circuit, and we should specify the quantum bit as the parameter\n",
-    "mycircuit.x(qreg[0]) # (quantum) bits are enumerated starting from 0\n",
-    "# NOT operator or x-gate is applied to the first qubit of the quantum register\n",
-    "\n",
-    "# let's run our codes until now, and then draw our circuit\n",
-    "print(\"Everything looks fine, let's continue ...\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# we use matplotlib_circuit_drawer\n",
-    "#     we shortly refer it as \"drawer\" in our codes\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "# let's draw our circuit now \n",
-    "drawer(mycircuit)\n",
-    "# re-execute me if you DO NOT see the circuit diagram"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b>Congratulations!</b> if you see your diagram :-)\n",
-    "\n",
-    "<i><u> Remak</u></i>: Qiskit has its own counters to enumerate the objects ($ q2_0 $, $ c2_0 $, etc.). \n",
-    "<ul>\n",
-    "    <li> They might be useful for debugging, but currently you can simply discard this part.\n",
-    "    <li> You may also notice that when you re-run the same codes, the index of objects will be increased.\n",
-    "</ul>\n",
-    "\n",
-    "The value of the quantum bit is 0 at the beginning. Technically, we denote is as $ \\ket{0} $, called <b><i>ket</i>-notation</b>.\n",
-    "\n",
-    "The value of the classical bit is also 0 at the beginning. \n",
-    "\n",
-    "Classical or quantum, each bit is represented as a straight line. You may think of it as a wire.\n",
-    "\n",
-    "The x-gate is shown as a square.\n",
-    "\n",
-    "The value of the quantum bit is expected to be $ \\ket{1} $ after the operator.\n",
-    "\n",
-    "Let's measure the first qubit (define a mesurement operator), and then execute our circuit and see the result."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# measurement is defined by associating a quantum bit to a classical bit\n",
-    "mycircuit.measure(qreg[0],creg[0])\n",
-    "# the result will be stored in the classical bit\n",
-    "\n",
-    "print(\"Everything looks fine, let's continue ...\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# let's draw the circuit again to see how the measurement is defined\n",
-    "drawer(mycircuit)\n",
-    "# reexecute me if you DO NOT see the circuit diagram"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# we are done with design of our circuit\n",
-    "# now we can execute it\n",
-    "# we execute quantum circuits many times (WHY?)\n",
-    "\n",
-    "# we use method \"execute\" and object \"Aer\" from qiskit library\n",
-    "from qiskit import execute, Aer\n",
-    "\n",
-    "# we create a job object for execution of the circuit\n",
-    "# there are three parameters\n",
-    "#     1. mycircuit\n",
-    "#     2. beckend on which it will be executed: we will use local simulator\n",
-    "#     3. how_many_times will it be executed, let's pick it as 1024\n",
-    "job = execute(mycircuit,Aer.get_backend('qasm_simulator'),shots=1024)\n",
-    "\n",
-    "# we can get the result of the outcome as follows\n",
-    "counts = job.result().get_counts(mycircuit)\n",
-    "print(counts)\n",
-    "\n",
-    "# usually quantum programs produce probabilistic outcomes "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We expect to see 1 in each execution, and so the output should be $ \\{\\mbox{'1'}:~1024\\} $. \n",
-    "\n",
-    "That is, the outcome 1 is measured 1024 times.\n",
-    "\n",
-    "<i>The output is composed by pairs, and each pair showing the measurement outcome and how many times it was measured.</i> \n",
-    "<br>\n",
-    "<i>For example, if the output is $ \\{\\mbox{'0': 500, '1': 524}\\} $, then we know that the outcome 0 is measured 500 times and the outcome 1 is measured 524 times. </i>\n",
-    "\n",
-    "<b><i> Quantum programs usually give probabilistic outcomes. \n",
-    "    \n",
-    "Therefore, we should execute them many times to get more reliable outcomes. </b></i> "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> My second quantum circuit </h3>\n",
-    "\n",
-    "Let's create a quantum circuit with four quantum bits. \n",
-    "\n",
-    "We use almost the same code with small modifications. \n",
-    "\n",
-    "Our comments explain only the modifications."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# \n",
-    "# My second quantum circuit\n",
-    "#\n",
-    "\n",
-    "# we import all at once\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "# we will use 4 quantum bits and 4 classical bits\n",
-    "qreg2 =  QuantumRegister(4)\n",
-    "creg2 = ClassicalRegister(4)\n",
-    "\n",
-    "mycircuit2 = QuantumCircuit(qreg2,creg2)\n",
-    "\n",
-    "# I will apply x-gate to the first quantum bit twice\n",
-    "mycircuit2.x(qreg2[0])\n",
-    "mycircuit2.x(qreg2[0])\n",
-    "\n",
-    "# I will apply x-gate to the fourth quantum bit once\n",
-    "mycircuit2.x(qreg2[3])\n",
-    "\n",
-    "# I will apply x-gate to the third quantum bit three times\n",
-    "mycircuit2.x(qreg2[2])\n",
-    "mycircuit2.x(qreg2[2])\n",
-    "mycircuit2.x(qreg2[2])\n",
-    "\n",
-    "# I will apply x-gate to the second quantum bit four times\n",
-    "mycircuit2.x(qreg2[1])\n",
-    "mycircuit2.x(qreg2[1])\n",
-    "mycircuit2.x(qreg2[1])\n",
-    "mycircuit2.x(qreg2[1])\n",
-    "\n",
-    "# if the size of quantum and classical registers are the same, we can define measurements with a single line code\n",
-    "mycircuit2.measure(qreg2,creg2)\n",
-    "# then each quantum bit and classical bit is associated with respect to their indices\n",
-    "\n",
-    "# let's run our codes until now, and then draw our circuit\n",
-    "\n",
-    "print(\"Everything looks fine, let's continue ...\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "drawer(mycircuit2)\n",
-    "# re-execute me if you DO NOT see the circuit diagram"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2 </h3>\n",
-    "\n",
-    "Guess the outcome by checking the circuit.\n",
-    "\n",
-    "Then, compare your guess with the result obtained after executing our circuit 500 times."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "job = execute(mycircuit2,Aer.get_backend('qasm_simulator'),shots=500)\n",
-    "counts = job.result().get_counts(mycircuit2)\n",
-    "print(counts)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> An important technical note:</h3> \n",
-    "\n",
-    "In Qiskit the outcomes are read from the classical register bottom to top \n",
-    "$$ creg[3],~creg[2],~creg[1],~creg[0] $$\n",
-    "and so, we see the <b><u><i>reverse</i></u></b> of what we expected. \n",
-    "\n",
-    "<i>If you think the overall output as a single number, then it is assumed that the upper bits are the least significant bits.</i>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Reverse the output </h3>\n",
-    "\n",
-    "Let's write a method to print the reverse the outcomes as we expected.\n",
-    "\n",
-    "You may use this method later."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def print_outcomes(counts): # takes a dictionary variable\n",
-    "    for outcome in counts: # for each key-value in dictionary\n",
-    "        reverse_outcome = ''\n",
-    "        for i in outcome: # each string can be considered as a list of characters\n",
-    "            reverse_outcome = i + reverse_outcome # each new symbol comes before the old symbol(s)\n",
-    "        print(reverse_outcome,\"is observed\",counts[outcome],\"times\")\n",
-    "\n",
-    "job = execute(mycircuit2,Aer.get_backend('qasm_simulator'),shots=1024)\n",
-    "counts = job.result().get_counts(mycircuit2) # counts is a dictionary object in python\n",
-    "print_outcomes(counts)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3>Pick a random number</h3>\n",
-    "\n",
-    "In your first circuit design task, you will be asked to apply x-gate randomly.\n",
-    "\n",
-    "Here is one of the method to pick a random number in python."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import randrange\n",
-    "n = 20\n",
-    "r=randrange(n) # pick a number from the list {0,1,...,n-1}\n",
-    "print(r)\n",
-    "\n",
-    "# test this method by using a loop\n",
-    "for i in range(10):\n",
-    "    print(randrange(n))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 3 </h3>\n",
-    "\n",
-    "Design a quantum circuit with 10 quantum bits and 10 classical bits.\n",
-    "\n",
-    "For each quantum bit, flip a coin, and apply x-gate if the outcome is head.\n",
-    "\n",
-    "Measure your quantum bits.\n",
-    "\n",
-    "Execute your circuit 128 times.\n",
-    "\n",
-    "Repeat this task as mush as you want, and enjoy your random choices."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B24_One_Bit_Solution.ipynb#task3\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B26_Coin_Flip-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B26_Coin_Flip-checkpoint.ipynb
deleted file mode 100755
index a124c87b4..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B26_Coin_Flip-checkpoint.ipynb
+++ /dev/null
@@ -1,212 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> Coin Flip: A Probabilistic Bit </h2>\n",
-    "\n",
-    "<h3> A fair coin </h3>\n",
-    "\n",
-    "A coin has two sides: <i>Head</i> and <i>Tail</i>.\n",
-    "\n",
-    "After flipping a coin, we can get a Head or Tail. We can represent these two cases by a single bit:\n",
-    "<ul>\n",
-    "    <li> 0 represents Head </li>\n",
-    "    <li> 1 represents Tail </li>\n",
-    "</ul>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Flipping a fair coin </h3>\n",
-    "\n",
-    "If our coin is fair, then the probability of obtaining a Head or Tail is equal:\n",
-    "\n",
-    "$ p= \\dfrac{1}{2} = 0.5 $.\n",
-    "\n",
-    "Coin-flipping can be defined as an operator:\n",
-    "<ul>\n",
-    "    <li> $ FairCoin(Head) = \\frac{1}{2} Head + \\frac{1}{2}Tail $ </li>\n",
-    "    <li> $ FairCoin(Tail) = \\frac{1}{2} Head + \\frac{1}{2}Tail $ </li>\n",
-    "</ul>\n",
-    "$\n",
-    "FairCoin = \\begin{array}{c|cc} & \\mathbf{Head} & \\mathbf{Tail} \\\\ \\hline \\mathbf{Head} & \\dfrac{1}{2} & \\dfrac{1}{2} \\\\  \\mathbf{Tail} & \\dfrac{1}{2} & \\dfrac{1}{2}  \\end{array}\n",
-    "$\n",
-    "\n",
-    "Or, by using 0 and 1:\n",
-    "\n",
-    "$\n",
-    "FairCoin = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & \\dfrac{1}{2} & \\dfrac{1}{2} \\\\  \\mathbf{1} & \\dfrac{1}{2} & \\dfrac{1}{2}  \\end{array}\n",
-    "$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1: Simulating FairCoin in Python</h3>\n",
-    "\n",
-    "Flip a fair coin 100 times. Calcuate the total number of heads and tails, and then compare them.\n",
-    "\n",
-    "Do the same experiment 1000 times.\n",
-    "\n",
-    "Do the same experiment 10,000 times.\n",
-    "\n",
-    "Do the same experiment 100,000 times.\n",
-    "\n",
-    "Do your results get close to the ideal case (the numbers of heads and tails are the same)?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first we import a procedure for picking a random number\n",
-    "from random import randrange\n",
-    "# randrange(m) returns a number randomly from the list {0,1,...,m-1}\n",
-    "# randrange(10) returns a number randomly from the list {0,1,...,9}\n",
-    "# here is an example\n",
-    "r=randrange(5)\n",
-    "print(\"I picked a random number between 0 and 4, which is \",r)\n",
-    "\n",
-    "#\n",
-    "# your solution is here\n",
-    "#\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B26_Coin_Flip_Solutions.ipynb#task1\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Flipping a biased coin </h3>\n",
-    "\n",
-    "Our coin may have a bias. \n",
-    "\n",
-    "For example, the probability of getting head is greater than the probability of getting tail.\n",
-    "\n",
-    "Here is an example:\n",
-    "\n",
-    "$\n",
-    "BiasedCoin = \\begin{array}{c|cc} & \\mathbf{Head} & \\mathbf{Tail} \\\\ \\hline \\mathbf{Head} & 0.6 & 0.6 \\\\  \\mathbf{Tail} & 0.4 & 0.4  \\end{array}\n",
-    "$\n",
-    "\n",
-    "Or, by using 0 and 1 as the states:\n",
-    "\n",
-    "$\n",
-    "BiasedCoin = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 0.6 & 0.6\\\\  \\mathbf{1} & 0.4 & 0.4 \\end{array}\n",
-    "$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2: Simulating BiasedCoin in Python</h3>\n",
-    "\n",
-    "Flip the following biased coin 100 times. Calcuate the total number of heads and tails, and then compare them.\n",
-    "\n",
-    "$\n",
-    "BiasedCoin = \\begin{array}{c|cc} & \\mathbf{Head} & \\mathbf{Tail} \\\\ \\hline \\mathbf{Head} & 0.6 & 0.6 \\\\  \\mathbf{Tail} & 0.4 & 0.4  \\end{array}\n",
-    "$\n",
-    "\n",
-    "\n",
-    "Do the same experiment 1000 times.\n",
-    "\n",
-    "Do the same experiment 10,000 times.\n",
-    "\n",
-    "Do the same experiment 100,000 times.\n",
-    "\n",
-    "Do your results get close to the ideal case $ \\mypar{ \\dfrac{ \\mbox{# of heads} }{ \\mbox{# of tails} } = \\dfrac{0.6}{0.4} = 1.50000000 } $?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B26_Coin_Flip_Solutions.ipynb#task2\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first we import a procedure for picking a random number\n",
-    "from random import randrange\n",
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B28_Coin_Flip_Game-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B28_Coin_Flip_Game-checkpoint.ipynb
deleted file mode 100755
index a882167c3..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B28_Coin_Flip_Game-checkpoint.ipynb
+++ /dev/null
@@ -1,221 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> A Game with two biased coins </h2>\n",
-    "\n",
-    "Your friend Asja has one euro and one cent. \n",
-    "\n",
-    "Both coins are biased, and the probabilities of getting heads and tails are as follows:\n",
-    "<ul>\n",
-    "    <li> one euro: head with probability $ 0.6 $ and tail with probability $ 0.4 $. </li>\n",
-    "    <li> one cent: head with probability $ 0.3 $ and tail with probability $ 0.7 $. </li>\n",
-    "</ul>\n",
-    "\n",
-    "Asja flips her coins based on the following <b>protocol</b>: \n",
-    "<ol> \n",
-    "    <li> she starts with flipping one euro, </li>\n",
-    "    <li> whenever she gets a head, she flips one euro, and </li>\n",
-    "    <li> whenever she gets a tail, she flips one cent. </li>\n",
-    "</ol>\n",
-    "\n",
-    "By using a single bit, we summarize all possible transitions of this game as follows:\n",
-    "\n",
-    "$\n",
-    "GameCoins = \\begin{array}{c|cc} & \\mathbf{Head} & \\mathbf{Tail} \\\\ \\hline \\mathbf{Head} & 0.6 & 0.3\\\\  \\mathbf{Tail} & 0.4 & 0.7  \\end{array} = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 0.6 & 0.3 \\\\  \\mathbf{1} & 0.4 & 0.7  \\end{array}\n",
-    "$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3>Task 1: Convience yourself </h3>\n",
-    "\n",
-    "Please convience yourself about the correctness of transitions given in the table.\n",
-    "\n",
-    "<i> Remark that there is no difference between getting head from one euro or getting head from one cent.\n",
-    "    \n",
-    "Therefore, one bit is enough to represent all transitions.\n",
-    "</i>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Tracing Asja's three coin tosses </h3>\n",
-    "\n",
-    "Suppose that Asja <b>secretly</b> tosses her coins based on the defined protocol.\n",
-    "\n",
-    "By using python, we can calculate the probabilities of Asja getting head and tail after three coin tosses.\n",
-    "\n",
-    "<i><b>Remark:</b> In the previous two tasks, the ideal ratio was easy to calculate. We did our experiments and compared our results with the ideal ratio. \n",
-    "\n",
-    "Here we will calculate the exact probabilities (the ideal ratio) by using python. (We will not do experiment.)\n",
-    "</i>\n",
-    "\n",
-    "We present our solution step by step."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# OUR SOLUTION\n",
-    "#\n",
-    "\n",
-    "# initial case\n",
-    "# We assume that the probability of getting head is 1 at the beginning,\n",
-    "#    because Asja will start with one euro.\n",
-    "prob_head = 1\n",
-    "prob_tail = 0\n",
-    "\n",
-    "\n",
-    "#\n",
-    "# first coin-flip\n",
-    "#\n",
-    "\n",
-    "# if the last result was head\n",
-    "new_prob_head_from_head = prob_head * 0.6\n",
-    "new_prob_tail_from_head = prob_head * 0.4\n",
-    "\n",
-    "# if the last result was tail\n",
-    "# we know that prob_tail is 0 at the beginning \n",
-    "#     but we still keep these two lines to have the same code for each iteration\n",
-    "new_prob_head_from_tail = prob_tail * 0.3\n",
-    "new_prob_tail_from_tail = prob_tail * 0.7\n",
-    "\n",
-    "# update the probabilities at the end of coin toss\n",
-    "prob_head = new_prob_head_from_head + new_prob_head_from_tail\n",
-    "prob_tail = new_prob_tail_from_head + new_prob_tail_from_tail\n",
-    "\n",
-    "#\n",
-    "# second coin-flip\n",
-    "#\n",
-    "# we do the same calculations\n",
-    "\n",
-    "new_prob_head_from_head = prob_head * 0.6\n",
-    "new_prob_tail_from_head = prob_head * 0.4\n",
-    "\n",
-    "new_prob_head_from_tail = prob_tail * 0.3\n",
-    "new_prob_tail_from_tail = prob_tail * 0.7\n",
-    "\n",
-    "prob_head = new_prob_head_from_head + new_prob_head_from_tail\n",
-    "prob_tail = new_prob_tail_from_head + new_prob_tail_from_tail\n",
-    "\n",
-    "#\n",
-    "# third coin-flip\n",
-    "#\n",
-    "# we do the same calculations\n",
-    "\n",
-    "new_prob_head_from_head = prob_head * 0.6\n",
-    "new_prob_tail_from_head = prob_head * 0.4\n",
-    "\n",
-    "new_prob_head_from_tail = prob_tail * 0.3\n",
-    "new_prob_tail_from_tail = prob_tail * 0.7\n",
-    "\n",
-    "prob_head = new_prob_head_from_head + new_prob_head_from_tail\n",
-    "prob_tail = new_prob_tail_from_head + new_prob_tail_from_tail\n",
-    "\n",
-    "# print prob_head and prob_tail\n",
-    "print(\"the probability of getting head\",prob_head)\n",
-    "print(\"the probability of getting tail\",prob_tail)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2: Tracing ten biased coin tosses </h3>\n",
-    "\n",
-    "By using python, calculate the probabilities of Asja getting head and tail after 10 coin tosses.\n",
-    "\n",
-    "$\n",
-    "GameCoins = \\begin{array}{c|cc} & \\mathbf{Head} & \\mathbf{Tail} \\\\ \\hline \\mathbf{Head} & 0.6 & 0.3\\\\  \\mathbf{Tail} & 0.4 & 0.7  \\end{array} = \\begin{array}{c|cc} & \\mathbf{0} & \\mathbf{1} \\\\ \\hline \\mathbf{0} & 0.6 & 0.3 \\\\  \\mathbf{1} & 0.4 & 0.7  \\end{array}\n",
-    "$\n",
-    "\n",
-    "Please use a loop in your solution."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B28_Coin_Flip_Game_Solution.ipynb#task2\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B32_Probabilistic_States-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B32_Probabilistic_States-checkpoint.ipynb
deleted file mode 100755
index 895dbba0c..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B32_Probabilistic_States-checkpoint.ipynb
+++ /dev/null
@@ -1,260 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2> Probabilistic States </h2>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Suppose that Asja flips a fair coin secretly.\n",
-    "\n",
-    "Because we do not see the result, our information about the outcome will be probabilistic:\n",
-    "\n",
-    "$\\rightarrow$ The result is Head with probability $0.5$ and the result is Tail with probability $0.5$.\n",
-    "\n",
-    "If the coin has a bias $ \\dfrac{Pr(Head)}{Pr(Tail)} = \\dfrac{3}{1}$, then our information about the outcome is as follows:\n",
-    "\n",
-    "$\\rightarrow$  The result is Head with probability $ 0.75 $ and the result is Tail with probability $ 0.25 $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<i><u>Solution</u>: The probability of getting Head is three times of the probability of getting Tail.\n",
-    "    <ul>\n",
-    "        <li>The total probability is 1. </li>\n",
-    "        <li> We divide 1 into four parts (three parts for Head and one part is for Tail),\n",
-    "        <li> $ \\dfrac{1}{4} = 0.25$,</li>\n",
-    "        <li> and then give three parts for Head ($0.75$) and one part for Tail ($0.25$).</li>\n",
-    "    </ul></i>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Listing probabilities as a column </h3>\n",
-    "\n",
-    "We have two different outcomes: Head (0) and Tail (1).\n",
-    "\n",
-    "Then, we can use a column of size 2 to hold the probabilities of getting Head and getting Tail.\n",
-    "\n",
-    "For the fair coin, our information after the coin-flip is $ \\myvector{0.5 \\\\ 0.5} $. \n",
-    "\n",
-    "For the biased coin, it is $ \\myvector{0.75 \\\\ 0.25} $.\n",
-    "\n",
-    "The first entry refers to the probability of getting Head, and the second entry refers to the probability of getting Tail.\n",
-    "\n",
-    " $ \\myvector{0.5 \\\\ 0.5} $ and $ \\myvector{0.75 \\\\ 0.25} $ are examples of 2-dimensional (column) vectors."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "Suppose that Balvis secretly flips a coin having bias $ \\dfrac{Pr(Head)}{Pr(Tail)} = \\dfrac{1}{4}$.\n",
-    "\n",
-    "Represent your information about the outcome as a column vector."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2 </h3>\n",
-    "\n",
-    "Suppose that Fyodor secretly rolls a loaded (tricky) dice with the bias \n",
-    "\n",
-    "$$ Pr(1):Pr(2):Pr(3):Pr(4):Pr(5):Pr(6) = 7:5:4:2:6:1 . $$\n",
-    "\n",
-    "Represent your information on the result as a column vector. Remark that the size of your column should be 6.\n",
-    "\n",
-    "You may use python for your calculations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# You may use python for your calculations.\n",
-    "#\n",
-    "all_portions = [7,5,4,2,6,1];\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B32_Probabilistic_States_Solutions.ipynb#task2\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Vector representation </h3>\n",
-    "\n",
-    "Suppose that we have a system with 4 distiguishable states: $ s_1 $, $s_2 $, $s_3$, and $s_4$.  \n",
-    "\n",
-    "We expect the system to be in one of them at any moment. \n",
-    "\n",
-    "By using the language of probability, we can also say that the system is in one of the states with probability 1, and in any other state with probabilty 0. \n",
-    "\n",
-    "Then, by using our column representation, we can show each state as a column vector:\n",
-    "\n",
-    "$$\n",
-    "    s_1 = \\myvector{1\\\\ 0 \\\\ 0 \\\\ 0}, s_2 = \\myvector{0 \\\\ 1 \\\\ 0 \\\\ 0}, s_3 = \\myvector{0 \\\\ 0 \\\\ 1 \\\\ 0}, \n",
-    "    \\mbox{ and } s_4 = \\myvector{0 \\\\ 0 \\\\ 0 \\\\ 1}.\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This representation helps us to represent our knowledge on a system when it is in more than one state with certain probabilities. \n",
-    "\n",
-    "Remember the case in which the coins are tossed secretly. \n",
-    "\n",
-    "For example, suppose that the system is in state $ s_1 $, $ s_2 $, $ s_3 $, and $ s_4 $ with probabilities $ 0.20 $, $ 0.25 $, $ 0.40 $, and $ 0.15 $, respectively. \n",
-    "\n",
-    "(<i>The total probability should be 1, i.e. $ 0.20+0.25+0.40+0.15 = 1.00 $</i>)\n",
-    "\n",
-    "Then, we can say that the system is in the following probabilistic state:\n",
-    "$$\n",
-    "    \\myvector{ 0.20 \\\\ 0.25 \\\\ 0.40 \\\\ 0.15 },\n",
-    "$$\n",
-    "where the summation of entries must be 1."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> Thus, we can show all information as a single object. </b>\n",
-    "\n",
-    "Nicely, <u>this probabilistic state</u> can also be written as the following summation:\n",
-    "\n",
-    "$$\n",
-    "    0.20 \\cdot \\myvector{1\\\\ 0 \\\\ 0 \\\\ 0} + 0.25 \\cdot \\myvector{0\\\\ 1 \\\\ 0 \\\\ 0} + 0.40 \\cdot \\myvector{0\\\\ 0 \\\\ 1 \\\\ 0} + 0.15 \\cdot  \\myvector{0\\\\ 0 \\\\ 0 \\\\ 1} =     \\myvector{0.20\\\\ 0 \\\\ 0 \\\\ 0} +   \\myvector{0\\\\ 0.25 \\\\ 0 \\\\ 0} +  \\myvector{0\\\\ 0 \\\\0.40 \\\\ 0} +  \\myvector{0\\\\ 0 \\\\ 0 \\\\ 0.15 } = \\myvector{ 0.20 \\\\ 0.25 \\\\ 0.40 \\\\ 0.15 }.\n",
-    "$$\n",
-    "\n",
-    "Here we use two basic arithmetic rules about the vectors:\n",
-    "<ol>\n",
-    "    <li> when a vector is multiplied with a number, then each entry of the vector is multiplied with this number, and, </li>\n",
-    "    <li> when two or more vectors are added up, the summation is done on the same entries."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 3 </h3>\n",
-    "\n",
-    "Verify the following equality.\n",
-    "\n",
-    "$$\n",
-    "    2 \\cdot \\mymatrix{r}{1\\\\-2\\\\3\\\\0} - 3 \\cdot \\mymatrix{r}{0\\\\4\\\\1\\\\-1} = \\mymatrix{r}{2 \\\\ -16 \\\\ 3 \\\\ 3}\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 4 </h3>\n",
-    "\n",
-    "For a system with 4 states, randomly create a probabilistic state, and print its entries, e.g., $ 0.16~~0.17~~0.02~~0.65 $.\n",
-    "\n",
-    "You may pick your random numbers between 0 and 100 (or 1000), and then divide each by 100 (or 1000) to represent it as a probability."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import randrange\n",
-    "\n",
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B32_Probabilistic_States_Solutions.ipynb#task4\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B46_Quantum_State-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B46_Quantum_State-checkpoint.ipynb
deleted file mode 100755
index 1f84b1b25..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B46_Quantum_State-checkpoint.ipynb
+++ /dev/null
@@ -1,212 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2>Quantum State</h2>\n",
-    "\n",
-    "The overall probability must be 1 when we observe a quantum system.\n",
-    "\n",
-    "For example, the following vectors <u>cannot</u> be a valid quantum state:\n",
-    "\n",
-    "$$\n",
-    "    \\myvector{ \\frac{1}{2} \\\\ \\frac{1}{2} } \n",
-    "    \\mbox{ and }\n",
-    "    \\myvector{ \\frac{\\sqrt{3}}{2} \\\\ \\frac{1}{\\sqrt{2}} }.\n",
-    "$$\n",
-    "\n",
-    "For the first vector: the probabilities of observing the states $\\ket{0} $ and $ \\ket{1} $ are $ \\frac{1}{4} $. \n",
-    "\n",
-    "So, the overall probability of getting a result is $ \\frac{1}{4} + \\frac{1}{4} = \\frac{1}{2} $, which is less than 1.\n",
-    "\n",
-    "For the second vector: the probabilities of observing the states $\\ket{0} $ and $ \\ket{1} $ are respectively $ \\frac{3}{4} $ and $ \\frac{1}{2} $. \n",
-    "\n",
-    "So, the overall probability of getting a result is $ \\frac{3}{4} + \\frac{1}{2} = \\frac{5}{4} $, which is greater than 1."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<font color=\"blue\"><b>The summation of amplitude squares must be 1 for a valid quantum state.</b></font>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<font color=\"blue\"><b>In other words, a quantum state can be represented by a vector having length 1, and vice versa.</b></font>\n",
-    "\n",
-    "<i>The summation of amplitude squares gives the square of the length of vector.\n",
-    "\n",
-    "But, this summation is 1, and its sqaure root is also 1. So, we directly use the term <u>length</u> in the defintion.</i>\n",
-    "\n",
-    "We represent a quantum state as $ \\ket{u} $ instead of $ u $.\n",
-    "\n",
-    "Remember the relation between the length and inner product: $ \\norm{u} = \\sqrt{\\inner{u}{u}} $.\n",
-    "\n",
-    "In quantum computation, we use almost the same notation for the inner product: $ \\braket{u}{u}$.\n",
-    "\n",
-    "$ \\norm{ \\ket{u} } = \\sqrt{ \\braket{u}{u} } = 1 $, or equivalently $ \\braket{u}{u} = 1 $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "Let $a$ and $b$ be real numbers.\n",
-    "\n",
-    "If the folllowing vectors are valid quantum states, then what can be the values of $a$ and $b$?\n",
-    "\n",
-    "$$\n",
-    "    \\ket{v} = \\myrvector{a \\\\ -0.1 \\\\ -0.3 \\\\ 0.4 \\\\ 0.5}\n",
-    "    ~~~~~ \\mbox{and} ~~~~~\n",
-    "   \\ket{u} = \\myrvector{ \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{b}} \\\\ -\\frac{1}{\\sqrt{3}} }.\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your code is here or you may find the values by hand (in mind)\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B46_Quantum_State_Solutions.ipynb#task1\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Quantum Operators </h3>\n",
-    "\n",
-    "Once the quantum state is defined, the definition of quantum operator is very easy.\n",
-    "\n",
-    "<font color=\"blue\"><b>Any length preserving matrix is a quantum operator, and vice versa.</b></font>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2</h3>\n",
-    "\n",
-    "Remember Hadamard operator:\n",
-    "\n",
-    "$$\n",
-    "    H = \\hadamard.\n",
-    "$$\n",
-    "\n",
-    "Let's randomly create a 2-dimensional quantum state, and test whether Hadamard operator preserves the length or not.\n",
-    "\n",
-    "Write a function that returns a randomly created 2-dimensional quantum state:\n",
-    "<ul>\n",
-    "    <li> Pick a random value between 0 and 100 </li>\n",
-    "    <li> Divide it by 100</li>\n",
-    "    <li> Take sqaure root of it</li>\n",
-    "    <li> Randomly determine its sign ($+$ or $-$)</li>\n",
-    "    <li> This is the first entry of the vector </li>\n",
-    "    <li> Find an appropriate value for the second entry </li>\n",
-    "    <li> Randomly determine its sign ($+$ or $-$)</li>\n",
-    "</ul>\n",
-    "\n",
-    "Write a function that determines whether a given vector is a valid quantum state or not.\n",
-    "\n",
-    "(Due to precision problem, the summation of squares may not be exactly 1 but very close to 1, e.g., 0.9999999999999998.)\n",
-    "\n",
-    "Repeat 10 times:\n",
-    "<ul>\n",
-    "    <li> Randomly create a quantum state </li>\n",
-    "    <li> Multiply Hadamard matrix with the randomly created quantum state </li>\n",
-    "    <li> Check whether the result quantum state is valid </li>\n",
-    "</ul>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B46_Quantum_State_Solutions.ipynb#task2\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B48_Superposition-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B48_Superposition-checkpoint.ipynb
deleted file mode 100755
index 6c416fd35..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B48_Superposition-checkpoint.ipynb
+++ /dev/null
@@ -1,391 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2>Superposition</h2>\n",
-    "\n",
-    "There is no classical counterpart of the concept \"superposition\".\n",
-    "\n",
-    "But, we can still use a classical analogy that might help us to give some intuitions.\n",
-    "\n",
-    "<h3> Probability distribution </h3>\n",
-    "\n",
-    "Suppose that Asja starts in $ \\myvector{1\\\\0} $ and secretly applies the probabilistic operator $ \\mymatrix{cc}{ 0.3 & 0.6 \\\\ 0.7 & 0.4 } $.\n",
-    "\n",
-    "Because she applies her operator secretly, our information about her state is probabilistic, which is calculated as\n",
-    "\n",
-    "$$\n",
-    "    \\myvector{0.3 \\\\ 0.7} = \\mymatrix{cc}{ 0.3 & 0.6 \\\\ 0.7 & 0.4 } \\myvector{1\\\\0}.\n",
-    "$$\n",
-    "\n",
-    "Asja is either in state 0 or in state 1.\n",
-    "\n",
-    "However, from our point of view, Asja is in state 0 and state 1 with probabilities $ 0.3 $ and $ 0.7 $, respectively.\n",
-    "\n",
-    "We can say that Asja in a probability distribution of states 0 and 1, being in both states at the same time.\n",
-    "\n",
-    "On the other hand, if we observe Asja's state, then our information about Asja becomes deterministic: either $ \\myvector{1 \\\\ 0} $ or $ \\myvector{0 \\\\ 1} $.\n",
-    "\n",
-    "We can say that after measurement the probabilistic state $ \\myvector{0.3 \\\\ 0.7}  $ collapses to either $ \\myvector{1 \\\\ 0} $ or $ \\myvector{0 \\\\ 1} $.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> The third experiment </h3>\n",
-    "\n",
-    "Now, we can explain the following experiment.\n",
-    "\n",
-    "<img src=\"../images/photon7.jpg\" width=\"65%\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> The initial Step </b>\n",
-    "\n",
-    "The photon is in state $ \\ket{v_0} = \\vzero $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> The first step </b>\n",
-    "\n",
-    "Hadamard is applied:\n",
-    "\n",
-    "$ \\ket{v_1} = \\hadamard \\vzero = \\vhadamardzero $.\n",
-    "\n",
-    "At this point, the photon is in a <b>superposition</b> of state $ \\ket{0} $ and state $ \\ket{1} $, <u>being in both states with the amplitudes</u> $ \\frac{1}{\\sqrt{2}} $ and $ \\frac{1}{\\sqrt{2}} $, respectively.\n",
-    "\n",
-    "The state of photon is $ \\ket{v_1} = \\vhadamardzero $, and we can represent it also as follows:\n",
-    "\n",
-    "$ \\ket{v_1} =  \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1} $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> The second step </b>\n",
-    "\n",
-    "Hadamard is applied again:\n",
-    "\n",
-    "We write the affect of Hadamard on states $ \\ket{0} $ and $ \\ket{1} $ as follows:\n",
-    "\n",
-    "$ H \\ket{0} = \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1} $\n",
-    "\n",
-    "$ H \\ket{1} = \\frac{1}{\\sqrt{2}} \\ket{0} - \\frac{1}{\\sqrt{2}} \\ket{1} $\n",
-    "\n",
-    "This representation helps us to see clearly why the state $ \\ket{1} $ disappears.\n",
-    "\n",
-    "Now, let's see the affect of Hadamard on the quantum state $ \\ket{v_1} =  \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1} $:\n",
-    "\n",
-    "$ \\ket{v_2} = H \\ket{v_1} = H \\mybigpar{ \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1} } = \\frac{1}{\\sqrt{2}} H \\ket{0} + \\frac{1}{\\sqrt{2}} H \\ket{1} $\n",
-    "\n",
-    "We can replace $ H\\ket{0} $ and $ H\\ket{1} $ as described above.\n",
-    "\n",
-    "$ \\ket{v_2} $ is formed by the summation of the following terms:\n",
-    "\n",
-    "$ \\frac{1}{\\sqrt{2}} H \\ket{0} = \\frac{1}{2} \\ket{0} + \\frac{1}{2} \\ket{1}  $\n",
-    "\n",
-    "$ \\frac{1}{\\sqrt{2}} H \\ket{1} = \\frac{1}{2} \\ket{0} - \\frac{1}{2} \\ket{1}  $\n",
-    "\n",
-    "<font color=\"blue\">The amplitude of $ \\ket{0} $ becomes 1, but the amplitude of $ \\ket{1} $ becomes 0 because of cancellation.</font>\n",
-    "\n",
-    "$ \\ket{v_2} = 1 \\cdot \\ket{0} + 0 \\cdot \\ket{1} = \\ket{0} $.\n",
-    "\n",
-    "The photon was in both states at the same time with <u>certain amplitudes</u>.\n",
-    "\n",
-    "After the second Hadamard, the results are <u>interfered with each other</u>.\n",
-    "\n",
-    "The interference can be constructive or destructive.\n",
-    "\n",
-    "In our examples, <font color=\"green\">the resulting $ \\ket{0} $s are interfered constructively</font>, but <font color=\"red\">the resulting $ \\ket{1} $s are interfered destructively</font>."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Observations </h3>\n",
-    "\n",
-    "<u>Probabilistic systems</u>: If there is a nonzero transition to a state, then it contributes to the probability of this state positively. \n",
-    "\n",
-    "<u>Quantum systems</u>: If there is a nonzero transition to a state, then we cannot make such an interpretation without knowing the other transtions to this state.\n",
-    "\n",
-    "If it is the only transition, then it contributes to the amplitude (and probability) of the state, and it does not matter whether the sign of the transition is positive or negative.\n",
-    "\n",
-    "If there is more than one transition, then depending on the summation of all transitions, we can determine whether a specific transition contributes or not.\n",
-    "\n",
-    "As a simple rule, if the final amplitude of the state and nonzero transition have the same sign, then it is a positive contribution; and, if they have the opposite signs, then it is a negative contribution."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "[on paper]\n",
-    "\n",
-    "Start in state $ \\ket{u_0} =  \\ket{1} $.\n",
-    "\n",
-    "Apply Hadamard operator to $ \\ket{u_0} $, i.e, find $ \\ket{u_1} = H \\ket{u_0} $.\n",
-    "\n",
-    "Apply Hadamard operator to $\\ket{u_1}$, i.e, find $ \\ket{u_2} = H \\ket{u_1} $.\n",
-    "\n",
-    "Observe the constructive and destructive interferences, when calculating $ \\ket{u_2} $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Being in a superposition </h3>\n",
-    "\n",
-    "A quantum system can be in more than one state with nonzero amplitudes.\n",
-    "\n",
-    "Then, we say that our system is in a superposition of these states.\n",
-    "\n",
-    "When evolving from a superposition, the resulting transitions may affect each other constructively and destructively. \n",
-    "\n",
-    "This can happen only because of having both negative or positive amplitudes. \n",
-    "\n",
-    "Otherwise, all nonzero transitions are added up to each other as in probababilistic systems."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Measurement </h3>\n",
-    "\n",
-    "We can measure a quantum system, and then the system is observed in one of its states.\n",
-    "\n",
-    "This is the most basic measurement in quantum computing. \n",
-    "\n",
-    "(There are more generic measurement operators, but we will not cover them.)\n",
-    "\n",
-    "The probability of the system to be observed in a specified state is the square value of its amplitude.\n",
-    "<ul>\n",
-    "    <li> If the amplitude of a state is zero, then this state cannot be observed. </li>\n",
-    "    <li> If the amplitude of a state is nonzero, then this state can be observed. </li>\n",
-    "</ul>\n",
-    "\n",
-    "For example, if the system is in quantum state \n",
-    "\n",
-    "$$\n",
-    "    \\myrvector{ -\\frac{\\sqrt{2}}{\\sqrt{3}} \\\\ \\frac{1}{\\sqrt{3}} },\n",
-    "$$\n",
-    "\n",
-    "then, after a measurement, we can observe the system in state $\\ket{0} $ with probability $ \\frac{2}{3} $ and in state $\\ket{1}$ with probability $ \\frac{1}{3} $.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h4> Collapsing </h4>\n",
-    "\n",
-    "After the measurement, the system collapses to the observed state, and so the system is no longer in a superposition.\n",
-    "\n",
-    "Thus, the information kept in a superposition is lost. \n",
-    "\n",
-    "In the above example, when the system is observed in state $\\ket{0}$, then the new state becomes $ \\myvector{1 \\\\ 0} $. \n",
-    "\n",
-    "If it is observed in state $\\ket{1}$, then the new state becomes $ \\myvector{0 \\\\ 1} $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2 </h3>\n",
-    "\n",
-    "We have a quantum system with four states: $\\ket{00}$, $ \\ket{01} $, $\\ket{10}$, and $ \\ket{11} $.\n",
-    "\n",
-    "We can also say that our system has two qubits.\n",
-    "\n",
-    "\n",
-    "Suppose that the system is in the following state:\n",
-    "\n",
-    "$ \\myrvector{ \\dfrac{ 1 }{  \\sqrt{3} - \\sqrt{ 5 + 2\\sqrt{6}} } \\\\ \\\\ \\dfrac{1}{ \\sqrt{3} - \\sqrt{ 7 + 2\\sqrt{12} } } \\\\ \\\\\n",
-    " \\dfrac{  1 }{ \\sqrt{5} - \\sqrt{  13 + 2\\sqrt{40} }  } \\\\ \\\\ \\dfrac{1}{ \\sqrt{ 7 } - \\sqrt{ 15 + 2 \\sqrt{56} } } }.  $\n",
-    " \n",
-    " Find the probability of observing the system in state $\\ket{00}$, $ \\ket{01} $, $\\ket{10}$, or $ \\ket{11} $.\n",
-    " \n",
-    " You may write a function to calculate the dominator of each fraction automatically, where its value is determined by three values $a$, $ b$, and $ c $ by assuming the form $  \\sqrt{a} - \\sqrt{b + 2 \\sqrt{c} } $.\n",
-    " \n",
-    " Verify that the total probability is 1 (or almost 1)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B48_Superposition_Solutions.ipynb#task2\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Z-gate (operator) </h3>\n",
-    "\n",
-    "The indentity operator $ I = \\mymatrix{cc}{1 & 0 \\\\ 0 & 1} $ does not affect the computation.\n",
-    "\n",
-    "What about the following operator?\n",
-    "\n",
-    "$ Z = \\Z $.\n",
-    "\n",
-    "It is very similar to the identity operator.\n",
-    "\n",
-    "Consider the quantum state $ \\ket{u} = \\myvector{ \\frac{3}{5} \\\\ \\frac{4}{5} }  $.\n",
-    "\n",
-    "Let's calculate the new quantum state after appying $ Z $ to $ \\ket{u} $:\n",
-    "\n",
-    "$ \\ket{u'} = Z \\ket{u} =  \\Z  \\myvector{ \\frac{3}{5} \\\\ \\frac{4}{5} } =  \\myrvector{ \\frac{3}{5} \\\\ -\\frac{4}{5} } $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The quantum states $ \\ket{u} $ and $ \\ket{u'} $ look similar. \n",
-    "\n",
-    "The probabilities of observing the state 0 and state 1 are the same when the system is in $ \\ket{u} $ or $ \\ket{u'} $.\n",
-    "\n",
-    "On the other hand, they are far away from each other as shown below: \n",
-    "\n",
-    "<img src=\"../images/Z_u.jpg\" width = \"40%\">\n",
-    "\n",
-    "For example, by applying Hadamard to each of them, the probability of observing the state 0 and state 1 may change (?)\n",
-    "\n",
-    "To observe this, we can do a simple experiment. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 3 </h3>\n",
-    "\n",
-    "Create a quantum ciruit with 5 qubits.\n",
-    "\n",
-    "Apply h-gate (Hadamard operator) to each qubit.\n",
-    "\n",
-    "Apply z-gate ($Z$ operator) to randomly picked qubits. (e.g., $ mycircuit.z(qreg[i]) $)\n",
-    "\n",
-    "Apply h-gate to each qubit \n",
-    "\n",
-    "Measure each qubit.\n",
-    "\n",
-    "Execute your program 1000 times.\n",
-    "\n",
-    "Compare the outcomes of the qubits affected by z-gates, and the outcomes of the qubits not affected by z-gates.\n",
-    "\n",
-    "Does z-gate change the outcome?\n",
-    "\n",
-    "Why?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# let's import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "# let's import randrange for random choices\n",
-    "from random import randrange\n",
-    "\n",
-    "#\n",
-    "# your code is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B48_Superposition_Solutions.ipynb#task3\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B60_Superdense_Coding-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B60_Superdense_Coding-checkpoint.ipynb
deleted file mode 100755
index 4e0a54891..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B60_Superdense_Coding-checkpoint.ipynb
+++ /dev/null
@@ -1,224 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 07, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2>Superdense Coding</h2>\n",
-    "\n",
-    "Asja has a qubit, initially set to $ \\ket{0} $.\n",
-    "\n",
-    "Balvis has a qubit, initially set to $ \\ket{0} $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Entanglement </h3>\n",
-    "    \n",
-    "Asja applies Hadamard operator to her qubit. \n",
-    "\n",
-    "The quantum state of Asja's qubit is $ \\vhadamardzero $.\n",
-    "\n",
-    "Then, Asja and Balvis combine their qubits. Their quantum state is\n",
-    "\n",
-    "$ \\vhadamardzero \\otimes \\vzero = \\myvector{ \\frac{1}{\\sqrt{2}} \\\\ 0 \\\\ \\frac{1}{\\sqrt{2}} \\\\ 0 }  $.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Asja and Balvis apply CNOT operator on two qubits.\n",
-    "\n",
-    "The new quantum state is\n",
-    "\n",
-    "$ \\CNOT \\myvector{ \\frac{1}{\\sqrt{2}} \\\\ 0 \\\\ \\frac{1}{\\sqrt{2}} \\\\ 0 }  = \\myvector{ \\frac{1}{\\sqrt{2}} \\\\ 0 \\\\0 \\\\ \\frac{1}{\\sqrt{2}} } = \\frac{1}{\\sqrt{2}}\\ket{00} + \\frac{1}{\\sqrt{2}}\\ket{11}  $.\n",
-    "\n",
-    "At this moment, Asja's and Balvis' qubits are correlated to each other.\n",
-    "\n",
-    "If we measure both qubits, we can observe either state $ \\ket{00} $ or state $ \\ket{11} $. \n",
-    "\n",
-    "Suppose that Asja observes her qubit secretly. \n",
-    "<ul>\n",
-    "    <li> When Asja sees the result $ \\ket{0} $, then Balvis' qubit also collapses to state $ \\ket{0} $. Balvis cannot observe state $ \\ket{1} $. </li>\n",
-    "    <li> When Asja sees the result $ \\ket{1} $, then Balvis' qubit also collapses to state $ \\ket{1} $. Balvis cannot observe state $ \\ket{0} $. </li>\n",
-    "</ul>\n",
-    "    \n",
-    "Experimental results have confirmed that this happens even if there is a physical distance between Asja's and Balvis' qubits. \n",
-    "\n",
-    "It seems correlated quantum particales can affect each other instantly, even if they are in the different part of the universe. \n",
-    "\n",
-    "If two qubits are correlated in this way, then we say that they are <b>entangled</b>.\n",
-    "\n",
-    "<i> <u>Technical note</u>: \n",
-    "    \n",
-    "If the quantum state of two qubits can be written as $ \\ket{u} \\otimes \\ket{v} $, then two qubits are not correlated, where $ \\ket{u} $ and $ \\ket{v} $ are the quantum states of the first and second qubits.\n",
-    "\n",
-    "On the other hand, if the quantum state of two qubits cannot be written as $ \\ket{u} \\otimes \\ket{v} $, then there is an entanglement between the qubits.\n",
-    "</i>\n",
-    "\n",
-    "<b> Entangled qubits can be useful </b>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> The quantum commmunication </h3>\n",
-    "\n",
-    "After having the entanglement, Balvis takes his qubit and goes away.\n",
-    "\n",
-    "Asja will send two bits of information by only sending her qubit.\n",
-    "\n",
-    "Now, we describe this protocol."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Asja has two bits of classical information: $ a,b \\in \\{0,1\\} $. \n",
-    "\n",
-    "There are four possible values for the pair $ (a,b) $:  $ (0,0), (0,1), (1,0),\\mbox{ or } (1,1) $. \n",
-    "\n",
-    "If $a$ is 1, then Asja applies z-gate, i.e., $ Z = \\Z $, to her qubit.\n",
-    "\n",
-    "If $b$ is 1, then Asja applies x-gate (NOT operator) to her qubit.\n",
-    "\n",
-    "Then, Asja sends her qubit to Balvis."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> After the communication </h3>\n",
-    "\n",
-    "Balvis has both qubits.\n",
-    "\n",
-    "Balvis applies cx-gate (CNOT operator), where Asja's qubit is the controller.\n",
-    "\n",
-    "Then, Balvis applies h-gate (Hadamard operator) to Asja's qubit.\n",
-    "\n",
-    "Balvis measures both qubits. \n",
-    "\n",
-    "The measurement result will be exactly $ (a,b) $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1</h3>\n",
-    "\n",
-    "Verify the correctness of the above protocol.\n",
-    "\n",
-    "For each pair of $ (a,b) \\in \\left\\{ (0,0), (0,1), (1,0),(1,1) \\right\\} $:\n",
-    "<ul>\n",
-    "    <li> Create a quantum curcuit with two qubits: Asja's and Balvis' qubits.</li>\n",
-    "    <li> Both are initially set to $ \\ket{0} $.</li>\n",
-    "    <li> Apply h-gate (Hadamard) to the first qubit. </li>\n",
-    "    <li> Apply cx-gate (CNOT) with parameters first-qubit and second-qubit. </li>\n",
-    "</ul>\n",
-    "\n",
-    "They are separated now.\n",
-    "\n",
-    "<ul>\n",
-    "    <li> If $ a $ is 1, then apply z-gate to the first qubit. </li>\n",
-    "    <li> If $ b $ is 1, then apply x-gate (NOT) to the first qubit. </li>\n",
-    "</ul>\n",
-    "\n",
-    "Asja sends her qubit to Balvis.\n",
-    "\n",
-    "<ul>\n",
-    "    <li> Apply cx-gate (CNOT) with parameters first-qubit and second-qubit.</li>\n",
-    "    <li> Apply h-gate (Hadamard) to the first qubit. </li>\n",
-    "    <li> Measure both qubits, and compare the results with pair $ (a,b) $. </li>\n",
-    "</ul>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "all_pairs = ['00','01','10','11']\n",
-    "\n",
-    "for pair in all_pairs:\n",
-    "    #\n",
-    "    # your code is here\n",
-    "    #\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B60_Superdense_Coding_Solution.ipynb#task1\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B88_Grovers_Search-checkpoint.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B88_Grovers_Search-checkpoint.ipynb
deleted file mode 100755
index b965fe882..000000000
--- a/community/awards/teach_me_quantum_2018/bronze/bronze/.ipynb_checkpoints/B88_Grovers_Search-checkpoint.ipynb
+++ /dev/null
@@ -1,548 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<div style=\"color:#777777;background-color:#ffffff;font-size:12px;text-align:right;\">\n",
-    "\tprepared by Abuzer Yakaryilmaz (QuSoft@Riga) | November 10, 2018\n",
-    "</div>\n",
-    "<table><tr><td><i> I have some macros here. If there is a problem with displaying mathematical formulas, please run me to load these macros.</i></td></td></table>\n",
-    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
-    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
-    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
-    "$ \\newcommand{\\inner}[2]{\\langle #1,#2\\rangle} $\n",
-    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
-    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
-    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
-    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
-    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
-    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
-    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
-    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
-    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
-    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
-    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
-    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
-    "$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
-    "$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
-    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
-    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
-    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
-    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
-    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
-    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h2>Grover's Search</h2>\n",
-    "\n",
-    "Grover's search algorithm is one of the well-known quantum algorithms.\n",
-    "\n",
-    "It finds a marked element in an unsorted list quadratically better than the classical algorithms.\n",
-    "\n",
-    "Grover's search algorithm iteratively applies two reflections.\n",
-    "\n",
-    "Its implementation is complicated, but its explanation is easy.\n",
-    "\n",
-    "Here, we describe Grover's search algorithm, and then emulate it on the unit circle. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Representation of data </h3>\n",
-    "\n",
-    "Suppose that we have 16 elements in our list.\n",
-    "\n",
-    "The list has marked and unmarked elements. (A marked element refers to a searching item.)\n",
-    "\n",
-    "Each quantum state will be associated with a different index of the list.\n",
-    "\n",
-    "Four qubits have 16 different states ($ \\ket{0000}, \\ldots, \\ket{1111} $), and so we use 4 qubits.\n",
-    "\n",
-    "We assume that when we keep the whole list \"quantumly\", we can check whether an item is marked or not in a single step by using its index.\n",
-    "\n",
-    "For example, if the element associated with the state $ \\ket{1101} $ is marked, then we can detect this by changing the sign of this state.\n",
-    "\n",
-    "We remind that changing the sign of a quantum state is one of the basic opearations.\n",
-    "\n",
-    "<i>In general, if we have a list of size $ 2^k $, then we can use $ k $ qubits and associate each state with one of the item in the list.</i>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3>Search in parallel</h3>\n",
-    "\n",
-    "We can access each element in the list with one of the basis states.\n",
-    "\n",
-    "We start in state $ \\ket{0000} $.\n",
-    "\n",
-    "Then, we apply Hadamard to each qubit.\n",
-    "\n",
-    "Remember that $ \\ket{0000} = \\ket{0} \\otimes \\ket{0} \\otimes \\ket{0} \\otimes \\ket{0}  $, or equivalently $ \\ket{0000} = \\ket{0}\\ket{0}\\ket{0}\\ket{0} $ by omitting tensor symbol.\n",
-    "\n",
-    "After Hadamard operator, our quantum state is\n",
-    "\n",
-    "$ \\ket{u} = H\\ket{0} \\otimes H\\ket{0} \\otimes H\\ket{0} \\otimes H\\ket{0} $, which is\n",
-    "\n",
-    "$$\n",
-    "    \\ket{u} =\n",
-    "    \\mypar{ \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1}  } \\otimes\n",
-    "    \\mypar{ \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1}  } \\otimes\n",
-    "    \\mypar{ \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1}  } \\otimes\n",
-    "    \\mypar{ \\frac{1}{\\sqrt{2}} \\ket{0} + \\frac{1}{\\sqrt{2}} \\ket{1}  }.\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "From this tensor product, we can get every basis state of 4 qubits having the amplitude $ \\frac{1}{4} $:\n",
-    "\n",
-    "\n",
-    "$$\n",
-    "   \\ket{u}= \\frac{1}{4} \\ket{0000} + \\frac{1}{4} \\ket{0001} +  \\frac{1}{4} \\ket{0010} +  \\frac{1}{4} \\ket{0011} \n",
-    "   + \\cdots \\cdots +  \\frac{1}{4} \\ket{1101}  +  \\frac{1}{4} \\ket{1110} +  \\frac{1}{4} \\ket{1111}.\n",
-    "$$\n",
-    " "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Thus, after Hadamard, we can access each index in parallel, \n",
-    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
-    "because we are in <u>a superposition of all basis states</u>, or in <u>a superposition of all indices of the list</u>.\n",
-    "\n",
-    "However, the probability of observing any basis state at this moment is exponentially small: $ \\frac{1}{16} $. \n",
-    "\n",
-    "(It is $ \\frac{1}{2^k} $ if there are $ 2^k $ elements.)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 1 </h3>\n",
-    "\n",
-    "Design a quantum circuit with 4 qubits.\n",
-    "\n",
-    "Apply Hadamard to each qubit.\n",
-    "\n",
-    "Execute your circuit 1600 times.\n",
-    "\n",
-    "You should observe each basis state around 100 times.\n",
-    "\n",
-    "Reexecute your circuit 16000 times."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import all necessary objects and methods for quantum circuits\n",
-    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\n",
-    "from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer\n",
-    "\n",
-    "#\n",
-    "# your solution is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B88_Grovers_Search_Solutions.ipynb#task1\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Unit circle representation</h3>\n",
-    "\n",
-    "For representing quantum state $ \\ket{u} $, we need 16-dimensional space.\n",
-    "\n",
-    "But, we can map $\\ket{u} $ to 2-dimensional space.\n",
-    "\n",
-    "We have marked elements and unmarket elements. \n",
-    "\n",
-    "We can group the states associated with marked elements and the state associated with unmarked elements.\n",
-    "\n",
-    "Then, we can represent $ \\ket{u} $ as a summation of two quantum states $ \\ket{u} = a \\ket{u_{marked}} + b \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "The states in $ \\ket{u_{marked}} $ and $ \\ket{u_{unmarked}} $ are different from each other.\n",
-    "\n",
-    "Therefore, they are orthogonal to each other. We can represent $ \\ket{u} = a \\ket{u_{marked}} + b \\ket{u_{unmarked}} $ in 2-dimension as below:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"../images/marked-unmarked.jpg\" width=\"40%\"> "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Remark that if all elements are marked, then $ \\ket{u} = \\ket{u_{marked}} $, and if all elements are unmarked, then $ \\ket{u} = \\ket{u_{unmarked}}$.\n",
-    "\n",
-    "For example, if we have 3 marked elements in our example, then we can find our parameters as follows.\n",
-    "\n",
-    "Let the marked states be $ \\ket{marked1} , \\ket{marked2} , \\ket{marked3} $.\n",
-    "\n",
-    "Let the unmarked states be $ \\ket{unmarked1} , \\ket{unmarked2} , \\ldots, \\ket{unmarked13} $.\n",
-    "\n",
-    "In $ \\ket{u} $, each of this state has the amplitude $ \\frac{1}{\\sqrt{16}} $:\n",
-    "\n",
-    "$$\n",
-    "    \\ket{u} = \\frac{1}{\\sqrt{16}} \\mypar{ \\ket{marked1} + \\ket{marked2} + \\ket{marked3} } +\n",
-    "            \\frac{1}{\\sqrt{16}} \\mypar{  \\ket{unmarked1} + \\ket{unmarked2} + \\cdots + \\ket{unmarked13} }\n",
-    "$$\n",
-    "\n",
-    "Then, our parameters are\n",
-    "<ul>\n",
-    "    <li>  $ \\ket{u_{marked}} = \\frac{1}{\\sqrt{3}} \\mypar{ \\ket{marked1} + \\ket{marked2} + \\ket{marked3} } $ and </li>\n",
-    "    <li>  $ a = \\frac{\\sqrt{3}}{\\sqrt{16}} $; and, </li>\n",
-    "    <li>  $ \\ket{u_{unmarked}} = \\frac{1}{\\sqrt{13}} \\mypar{ \\ket{unmarked1} + \\ket{unmarked2} + \\cdots + \\ket{unmarked13} } $ and </li>\n",
-    "    <li>  $ b = \\frac{\\sqrt{13}}{\\sqrt{16}} $. </li>\n",
-    "</ul>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The idea here is to select $ \\ket{u_{marked}} $ and $\\ket{u_{unmarked}} $ as quantum states, i.e., their lengths should be 1. \n",
-    "\n",
-    "In this way, we can also keep the ratio of $ \\frac{3}{13} $ as ratio of\n",
-    "<ul>\n",
-    "    <li> the probability of observing a state in $ \\ket{u_{marked}} $ and </li>\n",
-    "    <li> the probability of observing a state in $ \\ket{u_{unmarked}} $. </li>\n",
-    "</ul>\n",
-    "\n",
-    "Remark that the first probability is $ a^2 = \\frac{3}{16} $ and the second probability if $ b^2 = \\frac{13}{16} $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<i> So, in general, if we have $ 2^k $ elements and $ m $ of them are marked, then $ a = \\frac{\\sqrt{m}}{\\sqrt{2^k}} $ and  $ b= \\frac{\\sqrt{2^k - m}}{\\sqrt{2^k}} $. </i>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3>The idea behind Grover's search</h3>\n",
-    "\n",
-    "The idea behind Grover's search algorithm is that \n",
-    "<ul>\n",
-    "    <li> the amplitudes of the marked elements can be quickly amplified, </li>\n",
-    "    <li> and so the probability of observing one of the marked element quickly approches to 1.</li>\n",
-    "</ul>\n",
-    "\n",
-    "For \"quick\" amplification, we iteratively applies two reflections to our quantum states. \n",
-    "\n",
-    "The first reflection is a clockwise rotation, and the second rotation is counterclockwise. \n",
-    "\n",
-    "The second rotation always rotates twice of the first rotation. \n",
-    "\n",
-    "Therefore, our quantum state moves counterclockwise direction after two reflections."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As an analogy, we consider the rotation on the unit circle with angle $ \\frac{\\pi}{8} $ that starts in $ \\ket{0} $. \n",
-    "<ul>\n",
-    "    <li> After every 4 rotations, we visit in order $ \\ket{1} $, $ -\\ket{0} $, $ -\\ket{1} $, again $ \\ket{0} $, and so on. </li>\n",
-    "    <li> Remark that the probability of observing the state $ \\ket{1} $ oscillates between increasing and decreasing while rotating. </li>\n",
-    "</ul>\n",
-    "\n",
-    "Similarly, when iterating Grover's search algorithm, we should be careful when to stop. \n",
-    "<ul>\n",
-    "    <li> Because, after hitting a maximum value, these amplitudes are quickly decreased, and after hitting a minimum value, they are amplified again, and so on.</li>\n",
-    "</ul>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> One iteration of the algorithm </h3>\n",
-    "\n",
-    "Once we have the unit circle representation, then we can describe the algorithm very easily.\n",
-    "\n",
-    "Grover's search algorithm simply iterates two reflection, which can be implemented as two rotations.\n",
-    "\n",
-    "The axis of the first reflection is the quantum state $ \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "The axis of the second reflection is the first quantum state after Hadamard operators: $ \\ket{u} $.\n",
-    "\n",
-    "During all iterations, these axes are fixed. \n",
-    "\n",
-    "Remark that both of them depend on only the list and marked/unmarked elements."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"../images/reflection_axes.jpg\" width=\"70%\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<b> Grover's search algorithm: </b>\n",
-    "\n",
-    "Start in $ \\ket{u} $.\n",
-    "\n",
-    "Iteratively:\n",
-    "<ol>\n",
-    "    <li>Reflection over the first axis: Flip the sign of the states associated with the marked elements.\n",
-    "    </li> \n",
-    "    <li>Reflection over the second axis: Then, reflect the resulting quantum state over the $\\ket{u}$-axis.\n",
-    "    </li>\n",
-    "</ol>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "After the first reflection: the current quantum state rotates with angle $ -2 \\theta $.\n",
-    "\n",
-    "<img src=\"../images/grover_first_reflection.jpg\" width=\"70%\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "After the second reflection: the reflected state rotates with angle $ 4 \\theta $.\n",
-    "\n",
-    "<img src=\"../images/grover_second_reflection.jpg\" width=\"70%\">\n",
-    "\n",
-    "Then, the angle of the new quantum state is $ 3 \\theta $."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The second iteration:\n",
-    "<ul>\n",
-    "    <li> The angle of the new quantum state is $ 3 \\theta $. </li>\n",
-    "    <li> After the first reflection (rotation by $ -6 \\theta $): The reflected quantum state has angle $ -3 \\theta $. </li>\n",
-    "    <li> The angle between the reflected quantum state and the second reflection axis is $ 4 \\theta $.\n",
-    "    <li> With the second reflection, the reflected quantum state rotates $ 8 \\theta $.</li>\n",
-    "    <li> Thus, the angle of the newest state will be $ 5\\theta $. </li>\n",
-    "</ul>\n",
-    "\n",
-    "<b>Hence after each iteration the angle of the quantum state will be increased by $ 2 \\theta $.</b>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this way, the quantum state iteratively approaches to $ \\ket{u_{marked}} $.\n",
-    "\n",
-    "If we do not stop the iterations, then it passes  $ \\ket{u_{marked}} $, and starts to approaches $ - \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "If the quantum state is sufficiently close to $ \\ket{u_{marked}} $ and we make a measurement, we can observe a marked element with high probability.\n",
-    "\n",
-    "This is also the place to stop the iterations."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 2: Emulating Grover's search </h3>\n",
-    "\n",
-    "For this task, you can use the methods given in notebook <a href=\"B80_Reflections.ipynb\" target=\"_blank\">B80_Reflections</a>.\n",
-    "\n",
-    "Set the value of $ k $ to 4. Then, the size of list is $ 2^k = 16 $.\n",
-    "\n",
-    "Pick the value of $ m $ as 3, the number of the marked elements.\n",
-    "\n",
-    "As described above, $ \\ket{u} = \\sqrt{\\frac{3}{16}} \\ket{u_{marked}} + \\sqrt{\\frac{13}{16}} \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "Create a quantum circuit with single qubit.\n",
-    "\n",
-    "States $ \\ket{1} $ and $ \\ket{0} $ represents the quantum state $ \\ket{u_{marked}} $ and $ \\ket{u_{unmarked}}$, respectively.\n",
-    "\n",
-    "Then, $ \\ket{u} = \\sqrt{\\frac{13}{16}} \\ket{0} + \\sqrt{\\frac{3}{16}} \\ket{1} $.\n",
-    "\n",
-    "<b>Determine the angle $ \\theta $, the angle between $ \\ket{u} $ and $ \\ket{0} $.</b>\n",
-    "\n",
-    "<b>Iterate Grover's search algorithm once by using your quantum circuit.</b>\n",
-    "\n",
-    "For each reflection, use ry-gate (rotation).\n",
-    "<ul>\n",
-    "    <li> Define a list to store all quantum states (with their labels) that will be visited.</li>\n",
-    "    <li> Implement the first reflection on your qubit </li>\n",
-    "    <li> Read the current quantum state and store it on your list </li>\n",
-    "    <li> Implement the second reflection on your qubit </li>\n",
-    "    <li> Read the current quantum state and store it on your list</li>\n",
-    "    <li> Draw all visited quantum states with their labels </li>\n",
-    "    <li> Execute your circuit 100 times </li>\n",
-    "</ul>\n",
-    "\n",
-    "Is this single iteration enough to observe state $ \\ket{1} $ more than state $ \\ket{0} $? "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your solution\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B88_Grovers_Search_Solutions.ipynb#task2\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Taks 3 </h3>\n",
-    "\n",
-    "For this task, you can use the methods given in notebook <a href=\"B80_Reflections.ipynb\" target=\"_blank\"> B80_Reflections </a>.\n",
-    "\n",
-    "Set the value of $ k $ to 6. Then, the size of list is $ 2^k = 64 $.\n",
-    "\n",
-    "Pick the value of $ m $ as 1, the number of the marked elements.\n",
-    "\n",
-    "As described above, $ \\ket{u} = \\sqrt{\\frac{1}{64}} \\ket{u_{marked}} + \\sqrt{\\frac{63}{64}} \\ket{u_{unmarked}} $.\n",
-    "\n",
-    "Create a quantum circuit with single qubit.\n",
-    "\n",
-    "States $ \\ket{1} $ and $ \\ket{0} $ represents the quantum state $ \\ket{u_{marked}} $ and $ \\ket{u_{unmarked}}$, respectively.\n",
-    "\n",
-    "Then, $ \\ket{u} = \\sqrt{\\frac{63}{64}} \\ket{0} + \\sqrt{\\frac{1}{64}} \\ket{1} $.\n",
-    "\n",
-    "<b>Determine the angle $ \\theta $, the angle between $ \\ket{u} $ and $ \\ket{0} $.</b>\n",
-    "\n",
-    "<b>Iterate Grover's search algorithm <u>three times</u> by using your quantum circuit.</b>\n",
-    "\n",
-    "For each reflection, use ry-gate (rotation).\n",
-    "<ul>\n",
-    "    <li> Define a list to store all quantum states (with their labels) that will be visited.</li>\n",
-    "    <li> Iterate 3 times:\n",
-    "        <ul>\n",
-    "            <li> Implement the first reflection on your qubit </li>\n",
-    "            <li> Read the current quantum state and store it on your list </li>\n",
-    "            <li> Implement the second reflection on your qubit </li>\n",
-    "            <li> Read the current quantum state and store it on your list</li>\n",
-    "        </ul> </li>\n",
-    "    <li> Draw all visited quantum states with their labels </li>\n",
-    "    <li> Execute your circuit 100 times </li>\n",
-    "</ul>\n",
-    "\n",
-    "Is 3 iterations enough to observe state $ \\ket{1} $ more than state $ \\ket{0} $?\n",
-    "\n",
-    "Try 4, 5, 6, 7, 8, 9, and 10 iterations.\n",
-    "\n",
-    "What is the best iteration number?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#\n",
-    "# your code is here\n",
-    "#\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B88_Grovers_Search_Solutions.ipynb#task3\">click for our solution</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h3> Task 4 </h3>\n",
-    "\n",
-    "Repeat Task 3 for $ k = 8 $ and $ m = 1 $, but algorithmically find the best iteration number, say $B$. \n",
-    "\n",
-    "You may execute your circuit 1000 times to have more reliable results.\n",
-    "<hr>\n",
-    "<i> Hint:\n",
-    "\n",
-    "For each iteration number, you may check how many times the state $ \\ket{1} $ is observed. \n",
-    "<br><br>\n",
-    "This value should be at least 500.\n",
-    "\n",
-    "And, when this value starts to decrease, you may announce the previous iteration number as the best. \n",
-    "</i>\n",
-    "<hr>\n",
-    "Our solution outputs $ B $ as 12 in every execution."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"..\\bronze-solutions\\B88_Grovers_Search_Solutions.ipynb#task4\">click for our solution</a>"
-   ]
-  }
- ],
- "metadata": {
-  "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
-}
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B01_ Acknowledgements.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B01_ Acknowledgements.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B02_cells_in_notebook.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B02_cells_in_notebook.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B04_hello_from_quantum_world.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B04_hello_from_quantum_world.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B06_Python_Quick_Reference.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B06_Python_Quick_Reference.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B08_Python_Basics_Variables.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B08_Python_Basics_Variables.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B10_Python_Basics_Loops.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B10_Python_Basics_Loops.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B12_Python_Basics_Conditionals.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B12_Python_Basics_Conditionals.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B14_Python_Basics_Lists.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B14_Python_Basics_Lists.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B16_Lists_Vectors.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B16_Lists_Vectors.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B18_Lists_Inner_Product.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B18_Lists_Inner_Product.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B20_Lists_Matrices.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B20_Lists_Matrices.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B22_Lists_Tensor_Product.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B22_Lists_Tensor_Product.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B24_One_Bit.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B24_One_Bit.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B26_Coin_Flip.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B26_Coin_Flip.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B28_Coin_Flip_Game.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B28_Coin_Flip_Game.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B32_Probabilistic_States.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B32_Probabilistic_States.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B36_Probabilistic_Operators.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B36_Probabilistic_Operators.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B40_Quantum_Coin_flipping.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B40_Quantum_Coin_flipping.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B42_Hadamard.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B42_Hadamard.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B44_One_Qubit.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B44_One_Qubit.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B46_Quantum_State.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B46_Quantum_State.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B48_Superposition.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B48_Superposition.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B56_Two_Qubits.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B56_Two_Qubits.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B60_Superdense_Coding.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B60_Superdense_Coding.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B64_Phase_Kickback.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B64_Phase_Kickback.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B72_Rotations.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B72_Rotations.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B80_Reflections.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B80_Reflections.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze/B88_Grovers_Search.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze/B88_Grovers_Search.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/bronze/bronze_getting_started.ipynb b/community/awards/teach_me_quantum_2018/bronze/bronze_getting_started.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/1.Introduction.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/1.Introduction.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/10.Quantum error correction.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/10.Quantum error correction.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/2.Linear algebra.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/2.Linear algebra.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/3.Quantum mechanics.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/3.Quantum mechanics.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/4.Quantum computation.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/4.Quantum computation.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/5. Writing a quantum program with QISKit.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/5. Writing a quantum program with QISKit.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/6.First quantum algorithms.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/6.First quantum algorithms.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/7.Quantum teleportation.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/7.Quantum teleportation.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/8.Shor's algorithm.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/8.Shor's algorithm.ipynb
old mode 100755
new mode 100644
diff --git a/community/awards/teach_me_quantum_2018/intro2qc/9.Quantum criptography.ipynb b/community/awards/teach_me_quantum_2018/intro2qc/9.Quantum criptography.ipynb
old mode 100755
new mode 100644
diff --git a/community/games/Hello_Qiskit.ipynb b/community/games/Hello_Qiskit.ipynb
index 971a054f6..71688e37b 100644
--- a/community/games/Hello_Qiskit.ipynb
+++ b/community/games/Hello_Qiskit.ipynb
@@ -1889,7 +1889,9 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "keywords = {'Topics': ['Games', 'Bell inequality'], 'Commands': ['`x`', '`z`', '`h`', '`cx`']}"
+   ]
   }
  ],
  "metadata": {
diff --git a/community/games/README.md b/community/games/README.md
index fa8aa2ec3..aa071422c 100644
--- a/community/games/README.md
+++ b/community/games/README.md
@@ -19,6 +19,7 @@ This is exactly what we'd like to replicate in this folder. Here you'll find bas
 
 * [Random Terrain Generation](random_terrain_generation.ipynb) - A simple example of using quantum computers for the kind of procedural generation often used in games.
 
+* [Quantum Animations](quantum_animations.ipynb) - A simple example of making pixel art animations with quantum computers.
 
 ## Contributing
 
diff --git a/community/games/battleships_with_partial_NOT_gates.ipynb b/community/games/battleships_with_partial_NOT_gates.ipynb
index a3f5fa5d7..28a862631 100644
--- a/community/games/battleships_with_partial_NOT_gates.ipynb
+++ b/community/games/battleships_with_partial_NOT_gates.ipynb
@@ -779,6 +779,22 @@
     "<br>\n",
     "If you are reading this while running the game, you might be wondering where all the action has gone. Try clicking on the white space to the left of the output in the cell above to open it up."
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keywords = {'Topics': ['Games', 'NOT gates'], 'Commands': ['`u3`']}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/community/games/game_engines/outputs/animation.png b/community/games/game_engines/outputs/animation.png
new file mode 100644
index 000000000..45c4bd55c
Binary files /dev/null and b/community/games/game_engines/outputs/animation.png differ
diff --git a/community/games/game_engines/outputs/image1.png b/community/games/game_engines/outputs/image1.png
new file mode 100644
index 000000000..efd43149e
Binary files /dev/null and b/community/games/game_engines/outputs/image1.png differ
diff --git a/community/games/game_engines/outputs/image2.png b/community/games/game_engines/outputs/image2.png
new file mode 100644
index 000000000..e04fff2e5
Binary files /dev/null and b/community/games/game_engines/outputs/image2.png differ
diff --git a/community/games/game_engines/outputs/new_animation.png b/community/games/game_engines/outputs/new_animation.png
new file mode 100644
index 000000000..10e3d2c4b
Binary files /dev/null and b/community/games/game_engines/outputs/new_animation.png differ
diff --git a/community/games/quantum_animations.ipynb b/community/games/quantum_animations.ipynb
new file mode 100644
index 000000000..be5738471
--- /dev/null
+++ b/community/games/quantum_animations.ipynb
@@ -0,0 +1,501 @@
+{
+ "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 (and the image needs to be where this notebook is expecting it)\" width=\"500 px\" align=\"left\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# _*Quantum Animations*_\n",
+    "\n",
+    "The latest version of this notebook is available on https://github.com/qiskit/qiskit-tutorial.\n",
+    "\n",
+    "***\n",
+    "### Contributors\n",
+    "James R. Wootton, IBM Research\n",
+    "***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the notebook on [random terrain generation](random_terrain_generation.ipynb), we used qubits to make black and white pixel images.\n",
+    "\n",
+    "Here we will use the same principle to make colour images. For this we use the fact that each colour can be expressed using the [RGB_color_model](https://en.wikipedia.org/wiki/RGB_color_model). This uses three values to expressed a colour, which tell us how much red, green and blue must be mixed together. These values are typically in the range from 0 to 255. For example, black is (0,0,0), white is (255,255,255) and red is (255,0,0). With this in mind, we can simply have three separate monochromatic process for these three colour channels, and then combine them at the end.\n",
+    "\n",
+    "Another new aspect we'll introduce here is the ability to encode an existing image. For example, consider the 'image' below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plumber = {(0, 0): (255, 255, 255), (0, 1): (255, 255, 255), (0, 2): (255, 255, 255), (0, 3): (255, 0, 0), (0, 4): (255, 0, 0), (0, 5): (255, 0, 0), (0, 6): (255, 255, 255), (0, 7): (92, 64, 51), (1, 0): (255, 255, 255), (1, 1): (255, 0, 0), (1, 2): (255, 255, 255), (1, 3): (0, 0, 255), (1, 4): (0, 0, 255), (1, 5): (0, 0, 255), (1, 6): (0, 0, 255), (1, 7): (92, 64, 51), (2, 0): (255, 0, 0), (2, 1): (255, 0, 0), (2, 2): (255, 192, 203), (2, 3): (255, 0, 0), (2, 4): (0, 0, 255), (2, 5): (0, 0, 255), (2, 6): (255, 255, 255), (2, 7): (255, 255, 255), (3, 0): (255, 0, 0), (3, 1): (255, 0, 0), (3, 2): (255, 192, 203), (3, 3): (255, 0, 0), (3, 4): (0, 0, 255), (3, 5): (0, 0, 255), (3, 6): (255, 255, 255), (3, 7): (255, 255, 255), (4, 0): (255, 255, 255), (4, 1): (255, 0, 0), (4, 2): (255, 255, 255), (4, 3): (0, 0, 255), (4, 4): (0, 0, 255), (4, 5): (0, 0, 255), (4, 6): (0, 0, 255), (4, 7): (92, 64, 51), (5, 0): (255, 255, 255), (5, 1): (255, 255, 255), (5, 2): (255, 255, 255), (5, 3): (255, 0, 0), (5, 4): (255, 0, 0), (5, 5): (255, 0, 0), (5, 6): (255, 255, 255), (5, 7): (92, 64, 51), (6, 0): (255, 255, 255), (6, 1): (255, 255, 255), (6, 2): (255, 255, 255), (6, 3): (255, 255, 255), (6, 4): (255, 255, 255), (6, 5): (210, 180, 140), (6, 6): (255, 255, 255), (6, 7): (255, 255, 255), (7, 0): (255, 255, 255), (7, 1): (255, 255, 255), (7, 2): (255, 255, 255), (7, 3): (107, 92, 72), (7, 4): (210, 180, 140), (7, 5): (107, 92, 72), (7, 6): (255, 255, 255), (7, 7): (255, 255, 255)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is an 8x8 pixel picture of a tanuki plumber, expressed as a Python dictionary. For each coordinate of a pixel, it gives the corresponding RGB values. This can then be turned into a proper image. In this notebook, we'll use the `PIL` package to do this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAADUklEQVR4nO3dsY1VMRBA0We0HbE5ENID2wGtUAAxCQ2QISHyzSjo0cEmXyPLuucUYI8sXTmz133f19HW2j3BY04//8O92z0A7CQA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQ9je9w+vv906bPx/8Db3IDkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKTN/w8w/T7939fZ9ad9eN49QZobgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBtDb/ef61rdof7WqPrTzv+fIb/f/j68nl0fTcAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQNrx/wPwttP/B/j369vo+m4A0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgLSn3QNwtun3+7///D26vhuANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIG3d9z27wRpd/hoef5zz2csNQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZC2vnx8v3uGh/z487p7hIe8fHrePcJDTj9/NwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRA2n8dmy0sa+CUzwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=256x256 at 0x10B41A908>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from PIL import Image\n",
+    "from IPython.display import display\n",
+    "\n",
+    "def save_image(image,filename='image.png',scale=None):\n",
+    "\n",
+    "    img = Image.new('RGB',(8,8))\n",
+    "\n",
+    "    for x in range(img.size[0]):\n",
+    "        for y in range(img.size[1]):\n",
+    "            img.load()[x,y] = image[x,y]\n",
+    "\n",
+    "    if scale:\n",
+    "        img = img.resize((256,256))\n",
+    "\n",
+    "    img.save('game_engines/outputs/'+filename)\n",
+    "\n",
+    "    \n",
+    "save_image(plumber,scale=[300,300],filename='image1.png')\n",
+    "display(Image.open('game_engines/outputs/image1.png'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now turn this image into a quantum state. More precisely, we'll turn him into three states, with one for each colour channel. We will assign a bit string to each coordinate in the image, and use the probabilities of those bit strings as the value for the colour channels of that coordinate.\n",
+    "\n",
+    "The above image has $8x8=2^6$ pixels, and so needs 6 qubits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 6"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we set the probabilities for each bit string, we need to account for the fact that we do not have the freedom to do this arbitrarily. As probabilities, they must all be in the range from 0 to 1, and they must all sum to 1. We can do this simply by renormalizing. The corresponding amplitudes of the quantum state are then the square roots of these values.\n",
+    "\n",
+    "First we must decide which bitstrings belong to which values. This can be done in exactly the same way as for the terrain generation notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "L = int(2**(n/2))\n",
+    "\n",
+    "grid = {}\n",
+    "for y in range(L):\n",
+    "    for x in range(L):\n",
+    "        grid[(x,y)] = ''\n",
+    "\n",
+    "for (x,y) in grid:\n",
+    "    for j in range(n):\n",
+    "        if (j%2)==0:\n",
+    "            xx = np.floor(x/2**(j/2))\n",
+    "            grid[(x,y)] = str( int( ( xx + np.floor(xx/2) )%2 ) ) + grid[(x,y)]\n",
+    "        else:\n",
+    "            yy = np.floor(y/2**((j-1)/2))\n",
+    "            grid[(x,y)] = str( int( ( yy + np.floor(yy/2) )%2 ) ) + grid[(x,y)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following function then takes an image and a mapping of coordinates to bit strings and makes three quantum states, one for each colour channel. Each is expressed as a Python lists of amplitudes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "def image2state(image,grid):\n",
+    "    \n",
+    "    N = len(grid)\n",
+    "    state = [[0]*N,[0]*N,[0]*N] # different states for R, G and B\n",
+    "\n",
+    "    for pos in image:\n",
+    "        for j in range(3):\n",
+    "            state[j][ int(grid[pos],2) ] = np.sqrt( image[pos][j] ) # amplitude is square root of colour value\n",
+    "\n",
+    "    for j in range(3):        \n",
+    "        Z = sum(np.absolute(state[j])**2)\n",
+    "        state[j] = [amp / np.sqrt(Z) for amp in state[j]] # amplitudes are normalized\n",
+    "        \n",
+    "    return state\n",
+    "\n",
+    "\n",
+    "state = image2state(plumber,grid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can load the states into quantum circuits using the `initialize()` function of Qiskit, which initializes a circuit with a given quantum state. We can then manipulate the image in a quantum way. Here we'll use the statevector simulator to do this, which outputs the final quantum state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit import *\n",
+    "\n",
+    "backend = Aer.get_backend('statevector_simulator')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The final statevector is a set of amplitudes, but our encoding of RGB was done via the probabilities. For this reason, it would be useful to have the standard counts dictionary as we get from other simulators and real quantum devices. The following function performs the conversion."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def ket2counts (ket):\n",
+    "    \n",
+    "    counts = {}\n",
+    "    N = len(ket)\n",
+    "    n = int( np.log(N)/np.log(2) ) # figure out the qubit number that this state describes\n",
+    "    for j in range(N):\n",
+    "        string = bin(j)[2:]\n",
+    "        string = '0'*(n-len(string)) + string\n",
+    "        counts[string] = np.absolute(ket[j])**2 # square amplitudes to get probabilities\n",
+    "    \n",
+    "    return counts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's have a simple example where we load the image in and then extract the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q = QuantumRegister(n)\n",
+    "\n",
+    "counts = []\n",
+    "for j in range(3): # j=0 for red, j=1 for green, j=2 for blue\n",
+    "    qc = QuantumCircuit(q)\n",
+    "    qc.initialize( state[j], q )\n",
+    "    job = execute(qc, backend)\n",
+    "    counts.append( ket2counts( job.result().get_statevector() ) )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The only remaining job is to turn the three dictionaries of counts back into an image. This is going to be a bit ambiguous, because we need to undo our earlier normalization step. To do this, we'll assume that, for every colour channel, there is at least one pixel with the value 255. This means that the maximum probaility for each colour channel will be given the value 255, and all other values are assigned proportionally. This is done by the following function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAADYElEQVR4nO3dsWkdQRRA0b8fVWSUC4eqwagDtyLnjpW4gZ8JhHJl6metDpQsj2W45xQw+xj2MtnMtu/7ZWnX69kTHLP6/i9u8b8HjhEAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANLuxr+w+v3906b3x/sD3/J3kiYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKTNvw8wfT/9+8fs+tMe7s+eIM0JQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZC2Dd/ef7leZr+wL97w8vsz/P7D76fH0fXX/nvgIAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIG359wH43urvA3ze/oyu7wQgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASLs7ewDW9nl7Hl3/77/X0fWdAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBp277vox+4Dic2PP641fdnm13+8n94fScAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQJoASBMAaQIgTQCkCYA0AZAmANIEQNr26+HH2TMc8vL2cfYIhzz9vD97hEPm93/2BQInAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBEDaF+faLh/C7eNFAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=256x256 at 0x115FBB1D0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def counts2image(counts,grid):\n",
+    "    \n",
+    "    image = { pos:[0,0,0] for pos in grid}\n",
+    "\n",
+    "    for j in range(3):\n",
+    "\n",
+    "        rescale = 255/max(counts[j].values()) # rescale so that largest probability becomes value of 255\n",
+    "\n",
+    "        for pos in image:\n",
+    "            try:\n",
+    "                image[pos][j] = int( rescale*counts[j][grid[pos]] )\n",
+    "            except:\n",
+    "                image[pos][j] = int( rescale*counts[j][grid[pos]] )\n",
+    "\n",
+    "    for pos in image:\n",
+    "        image[pos] = tuple(image[pos])\n",
+    "\n",
+    "    return image\n",
+    "\n",
+    "\n",
+    "save_image( counts2image(counts,grid), scale=[300,300], filename='image2.png' )\n",
+    "display(Image.open('game_engines/outputs/image2.png'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our brave adventurer has been inside a quantum circuit and emerged intact!\n",
+    "\n",
+    "Now let's do some simple manipulation. We'll simply apply a rotation around the y axis over the course of a number of frames."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "frame_num = 20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These will then be compiled into an animated PNG using the `apng` package. Note that you'll need to run this notebook yourself in order to see this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from apng import APNG\n",
+    "import os\n",
+    "\n",
+    "state = image2state(plumber,grid)\n",
+    "\n",
+    "filenames = []\n",
+    "for f in range(frame_num):\n",
+    "        \n",
+    "    circuits = []\n",
+    "    for j in range(3):\n",
+    "        qc = QuantumCircuit(q)\n",
+    "        qc.initialize(state[j],q)\n",
+    "        qc.ry(2*np.pi*f/frame_num,q)\n",
+    "        circuits.append( qc )\n",
+    "\n",
+    "    job = execute(circuits, backend)\n",
+    "\n",
+    "    counts = []\n",
+    "    for j in range(3):\n",
+    "        counts.append( ket2counts( job.result().get_statevector(circuits[j]) ) )\n",
+    "        \n",
+    "    frame = counts2image(counts,grid)\n",
+    "    \n",
+    "    filename = 'frame_'+str(f)+'.png'\n",
+    "    save_image( counts2image(counts,grid), scale=[300,300], filename=filename)\n",
+    "    filenames.append( 'game_engines/outputs/' + filename )\n",
+    "\n",
+    "APNG.from_files(filenames,delay=250).save('game_engines/outputs/animation.png')\n",
+    "\n",
+    "for file in filenames:\n",
+    "    os.remove(file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![](game_engines/outputs/animation.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the above example, each qubit from each circuit is rotated in the y axis at the same rate. These rotations all cover the range from $0$ to $2\\pi$ over the course of the frames. To explore different possibilities, we could choose different fractions of $2\\pi$ to be covered over the frames. Setting this $>1$ will cause a faster rotation, and $<1$ will cause a slower one. Setting it to an integer will mean that the corresponding qubit will return to its original state by the final frame (or almost, anyway). For a non-integer, it will not.\n",
+    "\n",
+    "Below you can choose values of these fractions for each qubit for each colour channel via Jupyter widgets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2969de7e3f194c0c9616a4372d8aee08",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(VBox(children=(FloatSlider(value=1.0, description='qubit 0', max=5.0, step=0.01), FloatSlider(va…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import ipywidgets as widgets\n",
+    "\n",
+    "def make_box():\n",
+    "    children = [widgets.FloatSlider(value=1,max=5.0,step=0.01,description='qubit '+str(qubit),show=True) for qubit in range(n)]\n",
+    "    box = widgets.VBox(children)\n",
+    "    return box\n",
+    "\n",
+    "tab = widgets.Tab()\n",
+    "tab.children = [make_box() for j in range(3)]\n",
+    "channels = ['Red Channel','Green Channel','Blue Channel']\n",
+    "for j in range(3):\n",
+    "    tab.set_title(j, channels[j])\n",
+    "    \n",
+    "tab"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you've chosen, run the cells below to extract the values and create the animation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fraction = [[],[],[]]\n",
+    "for j in range(3):\n",
+    "    for qubit in range(n):\n",
+    "        fraction[j].append( tab.children[j].children[qubit].value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = image2state(plumber,grid)\n",
+    "\n",
+    "filenames = []\n",
+    "for f in range(frame_num):\n",
+    "        \n",
+    "    circuits = []\n",
+    "    for j in range(3):\n",
+    "        qc = QuantumCircuit(q)\n",
+    "        qc.initialize(state[j],q)\n",
+    "        for qubit in range(n):\n",
+    "            qc.ry(2*np.pi*fraction[j][qubit]*f/frame_num,q[qubit])\n",
+    "        circuits.append( qc )\n",
+    "\n",
+    "    job = execute(circuits, backend)\n",
+    "\n",
+    "    counts = []\n",
+    "    for j in range(3):\n",
+    "        counts.append( ket2counts( job.result().get_statevector(circuits[j]) ) )\n",
+    "        \n",
+    "    frame = counts2image(counts,grid)\n",
+    "    \n",
+    "    filename = 'frame_'+str(f)+'.png'\n",
+    "    save_image( counts2image(counts,grid), scale=[300,300], filename=filename)\n",
+    "    filenames.append( 'game_engines/outputs/' + filename )\n",
+    "\n",
+    "APNG.from_files(filenames,delay=250).save('game_engines/outputs/new_animation.png')\n",
+    "\n",
+    "for file in filenames:\n",
+    "    os.remove(file)    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![](game_engines/outputs/new_animation.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/community/games/quantum_awesomeness.ipynb b/community/games/quantum_awesomeness.ipynb
index 8f901b396..7028ad2cf 100644
--- a/community/games/quantum_awesomeness.ipynb
+++ b/community/games/quantum_awesomeness.ipynb
@@ -693,7 +693,9 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "keywords = {'Topics': ['Games', 'Hardware', 'Entanglement'], 'Commands': ['`rx`', '`cx`']}"
+   ]
   }
  ],
  "metadata": {
diff --git a/community/games/quantum_counterfeit_coin_problem.ipynb b/community/games/quantum_counterfeit_coin_problem.ipynb
index 1f6248c77..d591a911d 100644
--- a/community/games/quantum_counterfeit_coin_problem.ipynb
+++ b/community/games/quantum_counterfeit_coin_problem.ipynb
@@ -370,7 +370,9 @@
     "collapsed": true
    },
    "outputs": [],
-   "source": []
+   "source": [
+    "keywords = {'Topics': ['Counterfeit coin problem'], 'Commands': ['`h`']}"
+   ]
   }
  ],
  "metadata": {
diff --git a/community/games/quantum_slot_machine.ipynb b/community/games/quantum_slot_machine.ipynb
index fc63c9574..8e30132e4 100644
--- a/community/games/quantum_slot_machine.ipynb
+++ b/community/games/quantum_slot_machine.ipynb
@@ -95,7 +95,9 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "keywords = {'Topics': ['Games','Random number generation'], 'Commands': ['`h`','`shots=1`']}"
+   ]
   }
  ],
  "metadata": {
@@ -115,7 +117,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.1"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/community/games/quantum_tic_tac_toe.ipynb b/community/games/quantum_tic_tac_toe.ipynb
index 20794c5c5..8376fb05e 100644
--- a/community/games/quantum_tic_tac_toe.ipynb
+++ b/community/games/quantum_tic_tac_toe.ipynb
@@ -327,6 +327,15 @@
     "\n",
     "`B.run()`"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keywords = {'Topics': ['Games','Superposition','Entanglement'], 'Commands': ['Custom gates']}"
+   ]
   }
  ],
  "metadata": {
@@ -345,7 +354,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/community/games/random_terrain_generation.ipynb b/community/games/random_terrain_generation.ipynb
index 3bbf6b703..e6469cc7d 100644
--- a/community/games/random_terrain_generation.ipynb
+++ b/community/games/random_terrain_generation.ipynb
@@ -765,7 +765,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Clearly our Terrain maps are blockier than the example of Perlin noise shown at the top. This could be dealt with by adding more qubits, or simply by being careful in choosing how we apply the method. When generating terrain with Perlin noise, multiple layers are often used to create a good effect. Perhaps in future, some of those layers could be quantum."
+    "Clearly our Terrain maps are blockier than the example of Perlin noise shown at the top. This could be dealt with by adding more qubits, or simply by being careful in choosing how we apply the method. When generating terrain with Perlin noise, multiple layers are often used to create a good effect. Perhaps in future, some of those layers could be quantum.\n",
+    "\n",
+    "For another example of generation images using qubits, see the [Quantum Animations](quantum_animations.ipynb) notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keywords = {'Topics': ['Games','Procedural generation','Entanglement'], 'Commands': ['`ry`','`noise_model`','`basic_device_noise_model`']}"
    ]
   }
  ],
diff --git a/community/hello_world/string_comparison.ipynb b/community/hello_world/string_comparison.ipynb
index 012ff88f5..b5e494e19 100644
--- a/community/hello_world/string_comparison.ipynb
+++ b/community/hello_world/string_comparison.ipynb
@@ -151,10 +151,10 @@
     "            pos += 1\n",
     "        desired_vector[pos] = amplitude\n",
     "    if not inverse:\n",
-    "        qc.initialize(desired_vector, [ qr[i] for i in range(n) ] )\n",
+    "        qc.initialize(desired_vector, qr)\n",
     "        qc.barrier(qr)\n",
     "    else:\n",
-    "        qc.initialize(desired_vector, [ qr[i] for i in range(n) ] ).inverse()  #invert the circuit\n",
+    "        qc.initialize(desired_vector, qr).inverse()  #invert the circuit\n",
     "        for i in range(n):\n",
     "            qc.measure(qr[i], cr[i])\n",
     "    print()\n",
@@ -262,8 +262,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Similarity score of PROTOZOAN and YEAST is 0.833\n",
-      "Similarity score of PROTOZOAN and BACTERIAL is 0.975\n",
+      "Similarity score of PROTOZOAN and YEAST is 0.827\n",
+      "Similarity score of PROTOZOAN and BACTERIAL is 0.965\n",
       "[ANSWER] PROTOZOAN is most similar to BACTERIAL\n"
      ]
     }
@@ -347,7 +347,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.0"
+   "version": "3.6.1"
   },
   "toc": {
    "colors": {
diff --git a/community/terra/images/quantum_walk/8_white.jpg b/community/terra/images/quantum_walk/8_white.jpg
new file mode 100644
index 000000000..3454d12a2
Binary files /dev/null and b/community/terra/images/quantum_walk/8_white.jpg differ
diff --git a/community/terra/images/quantum_walk/8_white.png b/community/terra/images/quantum_walk/8_white.png
new file mode 100644
index 000000000..0d4814a20
Binary files /dev/null and b/community/terra/images/quantum_walk/8_white.png differ
diff --git a/community/terra/images/quantum_walk/executiontime.png b/community/terra/images/quantum_walk/executiontime.png
new file mode 100644
index 000000000..415ac101e
Binary files /dev/null and b/community/terra/images/quantum_walk/executiontime.png differ
diff --git a/community/terra/images/quantum_walk/fast.gif b/community/terra/images/quantum_walk/fast.gif
new file mode 100644
index 000000000..f2af41132
Binary files /dev/null and b/community/terra/images/quantum_walk/fast.gif differ
diff --git a/community/terra/images/quantum_walk/implement_toffoli.png b/community/terra/images/quantum_walk/implement_toffoli.png
new file mode 100644
index 000000000..cb303f7f4
Binary files /dev/null and b/community/terra/images/quantum_walk/implement_toffoli.png differ
diff --git a/community/terra/images/quantum_walk/random_walk.jpg b/community/terra/images/quantum_walk/random_walk.jpg
new file mode 100644
index 000000000..c7584e601
Binary files /dev/null and b/community/terra/images/quantum_walk/random_walk.jpg differ
diff --git a/community/terra/images/quantum_walk/random_walk.png b/community/terra/images/quantum_walk/random_walk.png
new file mode 100644
index 000000000..a2aa39141
Binary files /dev/null and b/community/terra/images/quantum_walk/random_walk.png differ
diff --git a/community/terra/images/quantum_walk/result.gif b/community/terra/images/quantum_walk/result.gif
new file mode 100644
index 000000000..e61d6979d
Binary files /dev/null and b/community/terra/images/quantum_walk/result.gif differ
diff --git a/community/terra/images/quantum_walk/toffoli.png b/community/terra/images/quantum_walk/toffoli.png
new file mode 100644
index 000000000..15b0ffc78
Binary files /dev/null and b/community/terra/images/quantum_walk/toffoli.png differ
diff --git a/community/terra/images/quantum_walk/whole_circuit.jpg b/community/terra/images/quantum_walk/whole_circuit.jpg
new file mode 100644
index 000000000..a4bd1e576
Binary files /dev/null and b/community/terra/images/quantum_walk/whole_circuit.jpg differ
diff --git a/community/terra/qis_adv/README.md b/community/terra/qis_adv/README.md
index ec46b24c4..78ca75f6a 100644
--- a/community/terra/qis_adv/README.md
+++ b/community/terra/qis_adv/README.md
@@ -31,6 +31,7 @@ which consists quantum operators that can be efficiently
 simulated (in polynomial time) using a classical computer.
 In addition, the Clifford group is used for Randomized Benchmarking.
 
+* [Quantum Walk](quantum_walk.ipynb):an example of quantum walk on circle graph with 2^N(N: number of qubits) lattice points. Quantum walker moves around circle in accordance with unitary coin(In this example Hadamard).  This quantum walk is simpler than topological quantum walk(above one).
 ## Contributing
 
 We welcome more examples in this folder, in particular, experimenting with the latest results in quantum information science.
diff --git a/community/terra/qis_adv/quantum_walk.ipynb b/community/terra/qis_adv/quantum_walk.ipynb
new file mode 100644
index 000000000..885b903f4
--- /dev/null
+++ b/community/terra/qis_adv/quantum_walk.ipynb
@@ -0,0 +1,525 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "yWabJ-GfTENP"
+   },
+   "source": [
+    "<img src=\"../../../images/qiskit-heading.png\" 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": [
+    "# Implementation of Quantum Walks on Cycle Graph\n",
+    "This notebook is based on the paper of  B L Douglas and J B Wang, \"Efficient quantum circuit implementation of quantum walks\", arXiv:0706.0304 [quant-ph]."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Contributors\n",
+    "Jordan Kemp (University of Chicago), Shin Nishio (Keio University), Ryosuke Satoh (Keio University), Desiree Vogt-Lee (University of Queensland), and Tanisha Bassan (The  Knowledge Society)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "There are many different types of quantum walks: a walker can walk on n-dimensional space or any limited graphs. First we will talk about the concept and dynamics of the quantum random walk and then show the implementation of a quantum walk on cycle graph."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random walk \n",
+    "A random walk is a dynamical path with a randomly evolving time system. The figure below shows a simple type of random walk. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/random_walk.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The dynamics can be regarded as a simple algorithm:\n",
+    "1. There is a $n$-dimensional space (in this case, one for simplicity) and a walker which starts at the point $x=0$\n",
+    "2. The walker then takes a step either forwards (towards $+x$) or backwards (towards $-x$) \n",
+    "\n",
+    "In the second step, the choice is made randomly (eg. a coin-flip). We can call this the \"Coin Operator\". \n",
+    "\n",
+    "For this system: $p+q = 1$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Quantum Walk \n",
+    "A quantum walk is the \"quantum version\" of a classical random walk. This means the coin function will be a Unitary gate ($U(2)$) which is non-random and reversible:\n",
+    "\n",
+    "$$p+q = U \\in U(2)$$\n",
+    "\n",
+    "In this notebook, we use a Hadamard gate for executing the coin function since it puts our qubits in a state of superposition, allowing for the  simulation of a coin based probability:\n",
+    "\n",
+    "$$H=\\frac{1}{\\sqrt{2}}\\left [{\\begin{array}{rr}1 & 1 \\\\ 1 & -1\\\\ \\end{array}}\\right]$$\n",
+    "\n",
+    "There are two kinds of random walks, continuous and discrete, and in this notebook we will use the discrete framework. In the discrete, unitary operations are made of coin and shift operators $U = SC$ which work in a state space.\n",
+    "\n",
+    "It is represented by an arbitrary undirected graph $G(V,E)$ where $V = {v_1, v_2, ..v_n}$ as nodes on the graph and $E = {(v_x, v_y) , ( v_i, v_j) …}$ as edges that combine different nodes together.\n",
+    "\n",
+    "The quantum walk extends into a position space where each node $v_i$ has a certain valency $d_i$ and is split into $d_i$ subnodes. The shifting operator then acts as $S (v_i, a_i) = (v_j, a_j)$ and with the coin operator, are unitary gates which combine the probability amplitudes with individual subnodes under each node.\n",
+    "\n",
+    "A unitary of $v_i$ with valency $d_i$ can be represented as $(d_i \\times d_i)$. The total state of system is defined by the Hilbert space \n",
+    "\n",
+    "$$H = H_c + H_p$$ \n",
+    "\n",
+    "Where $H_C$ is the coin Hilbert space and $H_P$ is the position Hilbert space. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Coin Operator \n",
+    "The first operation in a quantum random walk is the coin operator. The operator works by performing an arbitrary unitary transformation in the coin space which creates a rotation similar to “coin-flip” in random walk. This is namely the Hadamard gate, which models a balanced unitary coin. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The coin register will continue interfering with its position state until it is measured, after all intermediate steps. The results are very different from random walks as it doesn’t converge to a Gaussian distribution, but rather evolves into an asymmetric probability distribution. This happens because the Hadamard coin operator treats each basis vectors, |↑> and |↓> , differently. \n",
+    "\n",
+    "The rightwards path interferes more destructively as it is multiplied by -1, however, the leftwards path undergoes more constructive interference and the system tends to take steps towards the left. To reach symmetric results, both base vectors will start in a superposition of states (between  |↑> and |↓>). Another way to reach symmetry is use a different coin operator which doesn’t bias the coin towards a certain base vector, such as the Y gate:\n",
+    "\n",
+    "$$Y=\\frac{1}{\\sqrt{2}}\\left [{\\begin{array}{rr}1 & i \\\\ i & 1\\\\ \\end{array}}\\right]$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Quantum Walk on the Cycle Graph\n",
+    "\n",
+    "The goal of this notebook is to conduct a quantum random walk on circular graph which can be efficiently and simply implemented on the quantum circuit. The graph has 8 nodes with 2 attached edges which act as the subnodes on the circuit. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/8_white.jpg\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"350 px\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The operations propagate systemically around the graph as each node is a seperate bit-string value in lexicographic order. For a 2n graph, n qubits are required to encode the problem and 1 ancilla qubit is required for the subnode (coin). "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/whole_circuit.jpg\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"700 px\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The above circuit shows the whole process of the quantum walk on a cycle graph with $2^3$ nodes. \n",
+    "\n",
+    "The gray rectangular frame outlines a set of coin operators and shift operators. \n",
+    "\n",
+    "In this circuit, q[0] to q[2] represent the state (position) of quantum walker, and q[3] represents the coin operator.\n",
+    "\n",
+    "In this style, a programmer can insert the initial position of walker as a 3-qubit state. For example, if the input is $110$, then the position is $6$ (see the earlier cycle graph). \n",
+    "\n",
+    "The coin operator decides whether the walker proceeds clockwise or counterclockwise.\n",
+    "\n",
+    "INC is a gate that increments the state of the walker which is equal to a clockwise rotation in the cycle graph. \n",
+    "\n",
+    "DEC is gate that decrements the state of the walker which is equal to a counterclockwise rotation in cycle graph.\n",
+    "\n",
+    "After repeatedly executing the coin operator and the shift operator, we can measure the qubits (excluding the ancilla coin qubit), and it is then possible to know the position of the walker."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## $n$-qubit Toffoli\n",
+    "\n",
+    "The Toffoli gate is a CCNOT(CCX) gate. By using the Toffoli gate, X gates executed on Q2 if Q0 and Q1 is equal to 1.\n",
+    "\n",
+    "In our quantum walk implementation, we need more connections to expand the quantum walk implementation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/toffoli.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For example, CCX can be written as in the below circuit by using only the available gate sets of the IBMQ devices.\n",
+    "\n",
+    "Therefore, for more than 4 qubits, we can implement many qubits of CX gate (\"C$N$X gate\") using this method. Reference shown [here](\"https://journals.aps.org/pra/abstract/10.1103/PhysRevA.52.3457\")."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/implement_toffoli.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "C$N$X can be represented using C($N-1$)X as shown."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cnx(qc, *qubits):\n",
+    "    if len(qubits) >= 3:\n",
+    "        last = qubits[-1]\n",
+    "        # A matrix: (made up of a  and Y rotation, lemma4.3)\n",
+    "        qc.crz(np.pi/2, qubits[-2], qubits[-1])\n",
+    "        qc.cu3(np.pi/2, 0, 0, qubits[-2],qubits[-1])\n",
+    "        \n",
+    "        # Control not gate\n",
+    "        cnx(qc,*qubits[:-2],qubits[-1])\n",
+    "        \n",
+    "        # B matrix (pposite angle)\n",
+    "        qc.cu3(-np.pi/2, 0, 0, qubits[-2], qubits[-1])\n",
+    "        \n",
+    "        # Control\n",
+    "        cnx(qc,*qubits[:-2],qubits[-1])\n",
+    "        \n",
+    "        # C matrix (final rotation)\n",
+    "        qc.crz(-np.pi/2,qubits[-2],qubits[-1])\n",
+    "    elif len(qubits)==3:\n",
+    "        qc.ccx(*qubits)\n",
+    "    elif len(qubits)==2:\n",
+    "        qc.cx(*qubits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then need to decide the number of qubits $n$ to represent the walker's state (the whole circuit requires $n+1$ qubits)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "lHI4G7fgT9Wn"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from qiskit import IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
+    "from qiskit.tools.visualization import plot_histogram, plot_state_city\n",
+    "\n",
+    "n=3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 85
+    },
+    "colab_type": "code",
+    "id": "kLSxVQxerGyo",
+    "outputId": "b319f1d1-b5aa-4113-e12b-eecbf993a362"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<IBMQBackend('ibmq_qasm_simulator') from IBMQ(ibm-q-keio, keio-internal, keio-students)>,\n",
+       " <IBMQBackend('ibmq_20_tokyo') from IBMQ(ibm-q-keio, keio-internal, keio-students)>,\n",
+       " <IBMQBackend('ibmq_poughkeepsie') from IBMQ(ibm-q-keio, keio-internal, keio-students)>]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "IBMQ.load_accounts(hub=None)\n",
+    "IBMQ.backends()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then need to execute the increment and decrement gate in order for the shift operator to walk, including the C$N$X gates which changes the position of the walker based on the coin operator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "ysx7VXO2a95V"
+   },
+   "outputs": [],
+   "source": [
+    "def increment_gate(qwc, q, subnode):\n",
+    "  \n",
+    "  cnx(qwc, subnode[0], q[2], q[1], q[0])\n",
+    "  cnx(qwc, subnode[0], q[2], q[1])\n",
+    "  cnx(qwc, subnode[0], q[2])\n",
+    "  qwc.barrier()\n",
+    "  return qwc\n",
+    "\n",
+    "def decrement_gate(qwc, q, subnode):\n",
+    "  \n",
+    "  qwc.x(subnode[0])\n",
+    "  qwc.x(q[2])\n",
+    "  qwc.x(q[1])\n",
+    "  cnx(qwc, subnode[0], q[2], q[1], q[0])\n",
+    "  qwc.x(q[1])\n",
+    "  cnx(qwc, subnode[0], q[2], q[1])\n",
+    "  qwc.x(q[2])\n",
+    "  cnx(qwc, subnode[0], q[2])\n",
+    "  qwc.x(subnode[0])\n",
+    "  return qwc\n",
+    "  \n",
+    "def ibmsim(circ):\n",
+    "  ibmqBE = IBMQ.get_backend('ibmq_qasm_simulator')\n",
+    "  return execute(circ,ibmqBE, shots=1000).result().get_counts(circ)  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Rerun the coin and shift operators for n number of steps (in this case 15)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 408
+    },
+    "colab_type": "code",
+    "id": "PUUoi5T69zvX",
+    "outputId": "11b916d3-4cc9-40d2-9017-dc072de02630"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'0 100': 505, '0 111': 495}\n"
+     ]
+    }
+   ],
+   "source": [
+    "qnodes = QuantumRegister(n,'qc')\n",
+    "qsubnodes = QuantumRegister(1,'qanc')\n",
+    "csubnodes = ClassicalRegister(1,'canc')\n",
+    "cnodes = ClassicalRegister(n,'cr')\n",
+    "\n",
+    "qwc = QuantumCircuit(qnodes, qsubnodes, cnodes, csubnodes)\n",
+    "\n",
+    "\n",
+    "def runQWC(qwc, times):\n",
+    "    for i in range(times):\n",
+    "        qwc.h(qsubnodes[0])\n",
+    "        increment_gate(qwc, qnodes, qsubnodes[0])\n",
+    "        decrement_gate(qwc,qnodes,qsubnodes[0])\n",
+    "        qwc.measure(qnodes, cnodes)\n",
+    "\n",
+    "    return qwc\n",
+    "\n",
+    "import matplotlib as mpl\n",
+    "\n",
+    "step = 1\n",
+    "qwc = runQWC(qwc, step)\n",
+    "qwc.draw(output=\"mpl\")\n",
+    "result = ibmsim(qwc)\n",
+    "\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "LprBkgB9AGVr"
+   },
+   "outputs": [],
+   "source": [
+    "def runQWC(qwc, times):\n",
+    "    for i in range(times):\n",
+    "        qwc.h(qsubnodes[0])\n",
+    "        increment_gate(qwc, qnodes, qsubnodes[0])\n",
+    "        decrement_gate(qwc,qnodes,qsubnodes[0])\n",
+    "        qwc.measure(qnodes, cnodes)\n",
+    "\n",
+    "    return qwc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first qubit which is always 0, is the coin qubit.\n",
+    "The second to fourth, is the position of the walker (binary).\n",
+    "The distribution can be seen using plot_histogram."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x360 with 1 Axes>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = ibmsim(qwc)\n",
+    "plot_histogram(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Results\n",
+    "\n",
+    "The following animation is what the quantum walk looks like over its 19 iterations. The size of each node represents probability of the quantum walker existing in that position. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/fast.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Required Resources\n",
+    "\n",
+    "In this  algorithm, we needed $n+1$ qubits for a cycle graph with $2^n$ nodes. As you can see in the following graph, the time complexity increases linearly. This is the result of relation between execution time on 'qasm_simulator' and the number of steps."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"../images/quantum_walk/executiontime.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"center\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Discussion about Future Work and Applications\n",
+    "_Expansion of number of nodes on graph_ \n",
+    "\n",
+    "The walk implemented in this project required 3 qubits for 8 nodes plus an additional 1 qubit for the coin operator. The total time for iterating through coin and shift operator was 16 seconds for 100 flips. \n",
+    "\n",
+    "An example of a real world problem that can be solved using quantum random walks is the mapping of enzymes to understand their evolution when in contact with mutagens. This problem only requires 33 nodes which can be mapped out on 7 qubit circuit. This increase in qubits would increase the total time to 49 seconds for 100 flips. This is a scalable model which can continue to grow to map more complex graphs to problems. \n",
+    "\n",
+    "The time complexity for the quantum simulator approximately follows $({\\frac{m+1}{n+1}})^2$ if the number of nodes becomes $2^m$ from $2^n$. This value is based on number of qubits and is roughly estimated. \n",
+    "\n",
+    "## Conclusion\n",
+    "In this notebook we showed the basics of the quantum random walk and its implementation on a cyclic quantum circuit.\n",
+    "\n",
+    "The implemented algorithm requires $n+1$ qubits for any cycle graph with $2^n$ nodes. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "collapsed_sections": [],
+   "name": "quantum_walk.ipynb",
+   "provenance": [],
+   "version": "0.3.2"
+  },
+  "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/index.ipynb b/index.ipynb
index ba1a853d0..d03034999 100644
--- a/index.ipynb
+++ b/index.ipynb
@@ -105,7 +105,115 @@
     "* [Teach Me Qiskit 2018](community/awards/teach_me_qiskit_2018/index.ipynb)\n",
     "* [Teach Me Quantum 2018](community/awards/teach_me_quantum_2018/index.ipynb)\n",
     "\n",
-    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "The following lists show notebooks in the Qiskit tutorials that are relevant for various keywords. Note that these lists only include notebooks for which these keywords have been added.\n",
+       "\n",
+       "\n",
+       "## Index by Commands\n",
+       "\n",
+       "### Custom gates\n",
+       "* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)\n",
+       "\n",
+       "### `basic_device_noise_model`\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### `cx`\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)\n",
+       "\n",
+       "### `h`\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "* [quantum counterfeit coin problem](community/games/quantum_counterfeit_coin_problem.ipynb)\n",
+       "* [quantum slot machine](community/games/quantum_slot_machine.ipynb)\n",
+       "\n",
+       "### `noise_model`\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### `rx`\n",
+       "* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)\n",
+       "\n",
+       "### `ry`\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### `shots=1`\n",
+       "* [quantum slot machine](community/games/quantum_slot_machine.ipynb)\n",
+       "\n",
+       "### `u3`\n",
+       "* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)\n",
+       "\n",
+       "### `x`\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "\n",
+       "### `z`\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "\n",
+       "\n",
+       "## Index by Topics\n",
+       "\n",
+       "### Bell inequality\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "\n",
+       "### Counterfeit coin problem\n",
+       "* [quantum counterfeit coin problem](community/games/quantum_counterfeit_coin_problem.ipynb)\n",
+       "\n",
+       "### Entanglement\n",
+       "* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)\n",
+       "* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### Games\n",
+       "* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)\n",
+       "* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)\n",
+       "* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)\n",
+       "* [quantum slot machine](community/games/quantum_slot_machine.ipynb)\n",
+       "* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### Hardware\n",
+       "* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)\n",
+       "\n",
+       "### NOT gates\n",
+       "* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)\n",
+       "\n",
+       "### Procedural generation\n",
+       "* [random terrain generation](community/games/random_terrain_generation.ipynb)\n",
+       "\n",
+       "### Random number generation\n",
+       "* [quantum slot machine](community/games/quantum_slot_machine.ipynb)\n",
+       "\n",
+       "### Superposition\n",
+       "* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)\n",
+       "\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from IPython.display import display, Markdown\n",
+    "with open('index.md', 'r') as readme: content = readme.read(); display(Markdown(content))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
     "***  \n",
     "\n",
     "## License\n",
@@ -115,9 +223,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": []
   }
@@ -139,7 +245,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.3"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/index.md b/index.md
new file mode 100644
index 000000000..15f493256
--- /dev/null
+++ b/index.md
@@ -0,0 +1,78 @@
+The following lists show notebooks in the Qiskit tutorials that are relevant for various keywords. Note that these lists only include notebooks for which these keywords have been added.
+
+
+## Index by Commands
+
+### Custom gates
+* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)
+
+### `basic_device_noise_model`
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### `cx`
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)
+
+### `h`
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+* [quantum counterfeit coin problem](community/games/quantum_counterfeit_coin_problem.ipynb)
+* [quantum slot machine](community/games/quantum_slot_machine.ipynb)
+
+### `noise_model`
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### `rx`
+* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)
+
+### `ry`
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### `shots=1`
+* [quantum slot machine](community/games/quantum_slot_machine.ipynb)
+
+### `u3`
+* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)
+
+### `x`
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+
+### `z`
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+
+
+## Index by Topics
+
+### Bell inequality
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+
+### Counterfeit coin problem
+* [quantum counterfeit coin problem](community/games/quantum_counterfeit_coin_problem.ipynb)
+
+### Entanglement
+* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)
+* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### Games
+* [Hello Qiskit](community/games/Hello_Qiskit.ipynb)
+* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)
+* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)
+* [quantum slot machine](community/games/quantum_slot_machine.ipynb)
+* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### Hardware
+* [quantum awesomeness](community/games/quantum_awesomeness.ipynb)
+
+### NOT gates
+* [battleships with partial NOT gates](community/games/battleships_with_partial_NOT_gates.ipynb)
+
+### Procedural generation
+* [random terrain generation](community/games/random_terrain_generation.ipynb)
+
+### Random number generation
+* [quantum slot machine](community/games/quantum_slot_machine.ipynb)
+
+### Superposition
+* [quantum tic tac toe](community/games/quantum_tic_tac_toe.ipynb)
+
diff --git a/indexer.py b/indexer.py
new file mode 100644
index 000000000..9110e9aa0
--- /dev/null
+++ b/indexer.py
@@ -0,0 +1,34 @@
+import os
+import json
+
+index = {'Topics':{},'Commands':{}}
+for path, dirs, files in os.walk(os.getcwd()):
+    for file in files:
+        if file[-6:]=='.ipynb':
+            with open(path+'/'+file) as json_file:  
+                data = str(json.load(json_file))
+                start = data.find('keywords = ')
+                if (file!='indexer.ipynb') and('checkpoint' not in file) and start!=-1:
+                    data = data[(start+11):]
+                    end = data.find("}")
+                    data = data[:(end+1)]
+                    keywords = eval(data)
+                    rpath = (path+'/'+file).split('qiskit-tutorials/')[1]
+                    for kw_type in index:
+                        for topic in keywords[kw_type]:
+                            try:
+                                index[kw_type][topic].append(rpath)
+                            except:
+                                index[kw_type][topic] = [rpath]
+                                
+md = 'The following lists show notebooks in the Qiskit tutorials that are relevant for various keywords. Note that these lists only include notebooks for which these keywords have been added.\n\n'                          
+for kw_type in ['Commands','Topics']:
+    md += '\n## Index by '+kw_type+'\n\n'
+    for kw in sorted(index[kw_type]):
+        entry = '### ' + kw
+        for rpath in sorted(index[kw_type][kw]):
+            entry += '\n* [' + rpath.split('/')[-1].split('.')[0].replace('_',' ') + '](' + rpath + ')'
+        md += entry+'\n\n'
+
+with open('index.md','w') as file:
+    file.write(md)
diff --git a/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb b/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb
index b2d1831a2..71dbe7cbc 100644
--- a/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb
+++ b/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb
@@ -11,7 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# _*Qiskit Chemistry: Compiuting a Molecule's Dissociation Profile Using the Variational Quantum Eigensolver (VQE) Algorithm*_ \n",
+    "# _*Qiskit Chemistry: Computing a Molecule's Dissociation Profile Using the Variational Quantum Eigensolver (VQE) Algorithm*_ \n",
     "\n",
     "The latest version of this notebook is available on https://github.com/qiskit/qiskit-tutorials.\n",
     "\n",
diff --git a/qiskit/aqua/general/linear_systems_of_equations.ipynb b/qiskit/aqua/general/linear_systems_of_equations.ipynb
index d99261ada..3d857aa4d 100644
--- a/qiskit/aqua/general/linear_systems_of_equations.ipynb
+++ b/qiskit/aqua/general/linear_systems_of_equations.ipynb
@@ -38,11 +38,20 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "qiskit.providers.ibmq.ibmqprovider\n"
+     ]
+    }
+   ],
    "source": [
     "from qiskit.aqua import run_algorithm\n",
     "from qiskit.aqua.input import LinearSystemInput\n",
-    "from qiskit.aqua.algorithms.classical import ExactLPsolver\n",
+    "from qiskit.quantum_info import state_fidelity\n",
+    "from qiskit.aqua.algorithms.classical import ExactLSsolver\n",
     "import numpy as np"
    ]
   },
@@ -73,7 +82,13 @@
     "        'provider': 'qiskit.BasicAer',\n",
     "        'name': 'statevector_simulator'\n",
     "    }\n",
-    "}"
+    "}\n",
+    "\n",
+    "def fidelity(hhl, ref):\n",
+    "    solution_hhl_normed = hhl / np.linalg.norm(hhl)\n",
+    "    solution_ref_normed = ref / np.linalg.norm(ref)\n",
+    "    fidelity = state_fidelity(solution_hhl_normed, solution_ref_normed)\n",
+    "    print(\"fidelity %f\" % fidelity)"
    ]
   },
   {
@@ -94,7 +109,7 @@
     "1 & 0 \\\\\n",
     "0 & 2\n",
     "\\end{bmatrix}$$ with the vector $$\\vec{b}= \\left( \\begin{array}{c}1 \\\\ 4  \\end{array} \\right)$$\n",
-    "The `result` dictionary contains several return values. The HHL solution for $\\vec{x}$ is accessible by the key `'solution_hhl'`. For comparison, also the classical solution of the linear system of equations is calculated using standard linear algebra functions in numpy. The fidelity between the HHL solution and the classical solution is also given in the output. Furthermore, the probability is shown with which HHL was running successfully, i.e. the HHL ancillary qubit has been measured to be $|1\\rangle$."
+    "The `result` dictionary contains several return values. The HHL solution for $\\vec{x}$ is accessible by the key `'solution'`. For comparison, also the classical solution of the linear system of equations is calculated using standard linear algebra functions in numpy. The fidelity between the HHL solution and the classical solution is also given in the output. Furthermore, the probability is shown with which HHL was running successfully, i.e. the HHL ancillary qubit has been measured to be $|1\\rangle$."
    ]
   },
   {
@@ -114,7 +129,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -122,7 +137,9 @@
      "output_type": "stream",
      "text": [
       "solution  [1.05859+0.j 1.99245+0.j]\n",
-      "classical solution  [1. 2.]\n"
+      "classical solution  [1. 2.]\n",
+      "probability 0.024630\n",
+      "fidelity 0.999389\n"
      ]
     }
    ],
@@ -130,8 +147,11 @@
     "result = run_algorithm(params)\n",
     "print(\"solution \", np.round(result['solution'], 5))\n",
     "\n",
-    "classical_result = ExactLPsolver(matrix, vector).run()\n",
-    "print(\"classical solution \", np.round(classical_result['solution'], 5))"
+    "result_ref = ExactLSsolver(matrix, vector).run()\n",
+    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
+    "\n",
+    "print(\"probability %f\" % result['probability_result'])\n",
+    "fidelity(result['solution'], result_ref['solution'])"
    ]
   },
   {
@@ -143,7 +163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -151,7 +171,9 @@
      "output_type": "stream",
      "text": [
       "solution  [0.84664+0.j 2.01762+0.j]\n",
-      "classical solution  [1. 2.]\n"
+      "classical solution  [1. 2.]\n",
+      "probability 0.361437\n",
+      "fidelity 0.995605\n"
      ]
     }
    ],
@@ -164,8 +186,11 @@
     "result = run_algorithm(params2)\n",
     "print(\"solution \", np.round(result['solution'], 5))\n",
     "\n",
-    "classical_result = ExactLPsolver(matrix, vector).run()\n",
-    "print(\"classical solution \", np.round(classical_result['solution'], 5))"
+    "result_ref = ExactLSsolver(matrix, vector).run()\n",
+    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
+    "\n",
+    "print(\"probability %f\" % result['probability_result'])\n",
+    "fidelity(result['solution'], result_ref['solution'])"
    ]
   },
   {
@@ -177,21 +202,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "circuit_depth 12256\n",
-      "circuit_width 7\n"
+      "circuit_width 7\n",
+      "circuit_depth 12256\n"
      ]
     }
    ],
    "source": [
-    "print(\"circuit_depth\", result['circuit_info']['depth'])\n",
-    "print(\"circuit_width\", result['circuit_info']['width'])"
+    "print(\"circuit_width\", result['circuit_info']['width'])\n",
+    "print(\"circuit_depth\", result['circuit_info']['depth'])"
    ]
   },
   {
@@ -216,65 +241,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
     "matrix = [[1, 3], [3, 2]]\n",
     "vector = [1, 1]\n",
-    "params['input'] = {\n",
+    "params3 = params\n",
+    "params3['input'] = {\n",
     "    'name': 'LinearSystemInput',\n",
     "    'matrix': matrix,\n",
     "    'vector': vector\n",
-    "}"
+    "}\n",
+    "params3['reciprocal'] = {\n",
+    "    'negative_evals': True\n",
+    "}\n",
+    "params3['eigs'] = {\n",
+    "    'negative_evals': True\n",
+    "}\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "solution  [0.22147+0.j 0.22034-0.j]\n",
-      "classical solution  [0.14286 0.28571]\n"
+      "solution  [0.14223-5.e-05j 0.28622+7.e-05j]\n",
+      "classical solution  [0.14286 0.28571]\n",
+      "probability 0.000316\n",
+      "fidelity 0.999994\n"
      ]
     }
    ],
    "source": [
-    "result = run_algorithm(params)\n",
+    "result = run_algorithm(params3)\n",
     "print(\"solution \", np.round(result['solution'], 5))\n",
     "\n",
-    "classical_result = ExactLPsolver(matrix, vector).run()\n",
-    "print(\"classical solution \", np.round(classical_result['solution'], 5))"
+    "result_ref = ExactLSsolver(matrix, vector).run()\n",
+    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
+    "\n",
+    "print(\"probability %f\" % result['probability_result'])\n",
+    "fidelity(result['solution'], result_ref['solution'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Compared to the the first example, the circuit depth is increased approximately by a factor 2,5"
+    "Compared to the the first example, the circuit depth is increased approximately by a factor of 6"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "circuit_depth 30254\n",
-      "circuit_width 7\n"
+      "circuit_width 11\n",
+      "circuit_depth 73313\n"
      ]
     }
    ],
    "source": [
-    "print(\"circuit_depth\", result['circuit_info']['depth'])\n",
-    "print(\"circuit_width\", result['circuit_info']['width'])"
+    "print(\"circuit_width\", result['circuit_info']['width'])\n",
+    "print(\"circuit_depth\", result['circuit_info']['depth'])"
    ]
   },
   {
@@ -305,7 +342,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -318,7 +355,8 @@
     "          [0, 0, 0, 0, 0, 0, 1, 0],\n",
     "          [1, 0, 0, 0, 0, 0, 0, 5]]\n",
     "vector = [1, 0, 0, 0, 0, 0, 0, 1]\n",
-    "params['input'] = {\n",
+    "params4 = params\n",
+    "params4['input'] = {\n",
     "    'name': 'LinearSystemInput',\n",
     "    'matrix': matrix,\n",
     "    'vector': vector\n",
@@ -327,7 +365,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -336,42 +374,47 @@
      "text": [
       "solution  [ 0.18195-0.j  0.     -0.j  0.     -0.j -0.     +0.j  0.     +0.j\n",
       " -0.     +0.j -0.     -0.j  0.18041+0.j]\n",
-      "classical solution  [0.21053 0.      0.      0.      0.      0.      0.      0.15789]\n"
+      "classical solution  [0.21053 0.      0.      0.      0.      0.      0.      0.15789]\n",
+      "probability 0.935566\n",
+      "fidelity 0.981173\n"
      ]
     }
    ],
    "source": [
-    "result = run_algorithm(params)\n",
+    "result = run_algorithm(params4)\n",
     "print(\"solution \", np.round(result['solution'], 5))\n",
     "\n",
-    "classical_result = ExactLPsolver(matrix, vector).run()\n",
-    "print(\"classical solution \", np.round(classical_result['solution'], 5))"
+    "result_ref = ExactLSsolver(matrix, vector).run()\n",
+    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
+    "\n",
+    "print(\"probability %f\" % result['probability_result'])\n",
+    "fidelity(result['solution'], result_ref['solution'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Considering the circuit depth, it is increased approximately by a factor 10 compared to the two dimensional matrices. The circuit width is increased by two additional qubits"
+    "Considering the circuit depth and circuit width"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "circuit_depth 315281\n",
-      "circuit_width 9\n"
+      "circuit_width 9\n",
+      "circuit_depth 315281\n"
      ]
     }
    ],
    "source": [
-    "print(\"circuit_depth\", result['circuit_info']['depth'])\n",
-    "print(\"circuit_width\", result['circuit_info']['width'])"
+    "print(\"circuit_width\", result['circuit_info']['width'])\n",
+    "print(\"circuit_depth\", result['circuit_info']['depth'])"
    ]
   },
   {
@@ -390,7 +433,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -409,31 +452,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "params3 = params\n",
-    "params3[\"reciprocal\"] = {\n",
-    "    \"name\": \"Lookup\",\n",
-    "    \"negative_evals\": True\n",
+    "params5 = params\n",
+    "params5['algorithm'] = {\n",
+    "    'truncate_powerdim': False,\n",
+    "    'truncate_hermitian': False\n",
     "}\n",
-    "params3[\"eigs\"] = {\n",
-    "    \"expansion_mode\": \"suzuki\",\n",
-    "    \"expansion_order\": 2,\n",
-    "    \"name\": \"EigsQPE\",\n",
-    "    \"negative_evals\": True,\n",
-    "    \"num_ancillae\": 6,\n",
-    "    \"num_time_slices\": 70\n",
+    "params5['reciprocal'] = {\n",
+    "    'name': 'Lookup',\n",
+    "    'negative_evals': True\n",
     "}\n",
-    "params3[\"initial_state\"] = {\n",
-    "    \"name\": \"CUSTOM\"\n",
+    "params5['eigs'] = {\n",
+    "    'expansion_mode': 'suzuki',\n",
+    "    'expansion_order': 2,\n",
+    "    'name': 'EigsQPE',\n",
+    "    'negative_evals': True,\n",
+    "    'num_ancillae': 6,\n",
+    "    'num_time_slices': 70\n",
     "}\n",
-    "params3[\"iqft\"] = {\n",
-    "    \"name\": \"STANDARD\"\n",
+    "params5['initial_state'] = {\n",
+    "    'name': 'CUSTOM'\n",
     "}\n",
-    "params3[\"qft\"] = {\n",
-    "    \"name\": \"STANDARD\"\n",
+    "params5['iqft'] = {\n",
+    "    'name': 'STANDARD'\n",
+    "}\n",
+    "params5['qft'] = {\n",
+    "    'name': 'STANDARD'\n",
     "}"
    ]
   },
@@ -446,9 +493,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "random matrix:\n",
+      "[[ 0.284-0.j    -0.257-0.051j -0.124+0.033j  0.038+0.023j]\n",
+      " [-0.257+0.051j  0.404+0.j     0.067-0.079j  0.054+0.055j]\n",
+      " [-0.124-0.033j  0.067+0.079j  0.282-0.j     0.043+0.004j]\n",
+      " [ 0.038-0.023j  0.054-0.055j  0.043-0.004j  0.206-0.j   ]]\n",
+      "solution  [ 79.9768  +4.52073j  60.28272 +3.09211j  37.51853 -9.5858j\n",
+      " -35.02324+26.46894j]\n",
+      "classical solution  [ 76.1399  +1.92451j  57.30622 +1.20141j  35.96381-10.07775j\n",
+      " -32.03837+25.90593j]\n",
+      "probability 0.256771\n",
+      "fidelity 0.999946\n"
+     ]
+    }
+   ],
    "source": [
     "# set the random seed to get the same pseudo-random matrix for every run\n",
     "np.random.seed(1)\n",
@@ -460,31 +525,43 @@
     "print(np.round(m, 3))\n",
     "\n",
     "algo_input = LinearSystemInput(matrix=matrix, vector=vector)\n",
-    "hhl = HHL.init_params(params3, algo_input)\n",
+    "hhl = HHL.init_params(params5, algo_input)\n",
     "backend = BasicAer.get_backend('statevector_simulator')\n",
     "quantum_instance = QuantumInstance(backend=backend)\n",
-    "result_hhl = hhl.run(quantum_instance)\n",
+    "result = hhl.run(quantum_instance)\n",
     "print(\"solution \", np.round(result['solution'], 5))\n",
     "\n",
-    "classical_result = ExactLPsolver(matrix, vector).run()\n",
-    "print(\"classical solution \", np.round(classical_result['solution'], 5))"
+    "result_ref = ExactLSsolver(matrix, vector).run()\n",
+    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
+    "\n",
+    "print(\"probability %f\" % result['probability_result'])\n",
+    "fidelity(result['solution'], result_ref['solution'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The circuit depth and width are"
+    "The circuit width and depth are"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "circuit_width 12\n",
+      "circuit_depth 973537\n"
+     ]
+    }
+   ],
    "source": [
-    "print(\"circuit_depth\", result_hhl['circuit_info']['depth'])\n",
-    "print(\"circuit_width\", result_hhl['circuit_info']['width']"
+    "print(\"circuit_width\", result['circuit_info']['width'])\n",
+    "print(\"circuit_depth\", result['circuit_info']['depth'])"
    ]
   },
   {
@@ -511,7 +588,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.1"
+   "version": "3.7.1"
   }
  },
  "nbformat": 4,
diff --git a/qiskit/aqua/optimization/docplex.ipynb b/qiskit/aqua/optimization/docplex.ipynb
new file mode 100644
index 000000000..e2570c306
--- /dev/null
+++ b/qiskit/aqua/optimization/docplex.ipynb
@@ -0,0 +1,295 @@
+{
+ "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": [
+    "# _*Qiskit Aqua: Generating Ising Hamiltonians from optimization models with DOcplex*_\n",
+    "\n",
+    "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial.\n",
+    "\n",
+    "***\n",
+    "### Contributors\n",
+    "Atsushi Matsuo<sup>[1]</sup>, Takashi Imamichi<sup>[1]</sup>, Marco Pistoia<sup>[1]</sup>, Stephen Wood<sup>[1]</sup>\n",
+    "### Affiliation\n",
+    "- <sup>[1]</sup>IBMQ"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "There has been a growing interest in using quantum computers to find solutions of combinatorial problems. A heuristic approach for finding solutions of combinatorial problems on quantum computers is the quantum variational approach, such as the Variational Quantum \n",
+    "Eigensolver (VQE) algorithm (see https://arxiv.org/abs/1802.00171 and the Quantum Approximate Optimization Algorithm (QAOA) (see https://arxiv.org/abs/1411.4028). In order to use a quantum variational approach on quantum computers, first, we need to map a combinatorial problem to an Ising Hamiltonian. However Ising Hamiltonians are complicated and unintuitive. Mapping a combinatorial problem to Ising Hamiltonians can be a difficult and time-consuming task, requiring specialized knowledge.\n",
+    "\n",
+    "In this tutorial, we introduce a translator to automatically generate Ising Hamiltonians from classical optimization models. We will explain about classical optimization models later. The translator dramatically simplifies the task of designing and implementing quantum-computing-based solutions, for optimization problems, by automatically generating Ising Hamiltonians for different optimization problems. With the translator, all a user has to do is to write optimization models using DOcplex (see https://cdn.rawgit.com/IBMDecisionOptimization/docplex-doc/master/docs/index.html). DOcplex is a python library for optimization problems.\n",
+    "Then the translator will automatically generate Ising Hamiltonians from the models. Optimization models are short and intuitive. It is much easier to write optimization models compared to writing Ising Hamiltonians manually. \n",
+    "\n",
+    "The quantum variational approach works with the translator in Qiskit Aqua as follows:\n",
+    "1. Write an optimization model of the formulation with DOcplex.\n",
+    "2. Call the translator to transform the model into an Ising Hamiltonian.\n",
+    "3. Solve the problem with variational algorithms such as VQE and QAOA.\n",
+    "\n",
+    "\n",
+    "### Details of Optimization Models\n",
+    "The translator supports the generation of an Ising Hamiltonian from the following optimization model elements:\n",
+    "- Binary decision variables. \n",
+    "- Linear and quadratic terms in objective functions.\n",
+    "- Only equality constraints.  \n",
+    "\n",
+    "Input models are validated before transformation. If the model contains elements that are not from the supported set, an error will be raised.\n",
+    "\n",
+    "Even though there are restrictions, this type of optimization model can handle optimization problems such as maxcut, traveling salesman etc.\n",
+    "These are typical optimization problems. Examples of the translator being used for Maxcut and TSP problems can be found in the following tutorial:\n",
+    "- [Qiskit Aqua: Experimenting with MaxCut problem and Traveling Salesman problem with variational quantum eigensolver](maxcut_and_tsp.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A Usage Example: Maximize the number of variables by taking into account constraints\n",
+    "The following is a toy example of a maximization problem with constraints.\n",
+    "\n",
+    "\\begin{aligned}\n",
+    "   & \\text{maximize}\n",
+    "       & \\sum_{i} x_{i}\\\\\n",
+    "   & \\text{subject to}\n",
+    "       & \\sum_{i} i * x_{i}=3\\\\\n",
+    "       & & i \\in \\{1,2,3,4\\} \\\\\n",
+    "       & & x_i \\in \\{0,1\\}\\\\\n",
+    "\\end{aligned}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from docplex.mp.model import Model\n",
+    "\n",
+    "from qiskit import BasicAer\n",
+    "from qiskit.aqua import Operator, run_algorithm\n",
+    "from qiskit.aqua.algorithms import VQE, ExactEigensolver\n",
+    "from qiskit.aqua.components.optimizers import SPSA\n",
+    "from qiskit.aqua.components.variational_forms import RY\n",
+    "from qiskit.aqua import QuantumInstance\n",
+    "from qiskit.aqua.translators.ising import docplex\n",
+    "\n",
+    "# setup aqua logging\n",
+    "import logging\n",
+    "from qiskit.aqua import set_qiskit_aqua_logging\n",
+    "# set_qiskit_aqua_logging(logging.DEBUG)  # choose INFO, DEBUG to see the log"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating an optimization model of the above problem using DOcplex\n",
+    "An optimization model of the problem with DOcplex is written as follows.  \n",
+    "* First an instance of `Model` is created and variables for the model are defined. \n",
+    "* Next an objective function is written and passed to the model. The objective function is a function that we would like to minimize (or maximize).\n",
+    "* Finally constraints are added. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\\ This file has been generated by DOcplex\n",
+      "\\ ENCODING=ISO-8859-1\n",
+      "\\Problem name: max_vars\n",
+      "\n",
+      "Maximize\n",
+      " obj: x_1 + x_2 + x_3 + x_4\n",
+      "Subject To\n",
+      " c1: x_1 + 2 x_2 + 3 x_3 + 4 x_4 = 3\n",
+      "\n",
+      "Bounds\n",
+      "0 <= x_1 <= 1\n",
+      "0 <= x_2 <= 1\n",
+      "0 <= x_3 <= 1\n",
+      "0 <= x_4 <= 1\n",
+      "\n",
+      "Binaries\n",
+      " x_1 x_2 x_3 x_4\n",
+      "End\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create an instance of a model and variables\n",
+    "mdl = Model(name='max_vars')\n",
+    "x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(1,5)}\n",
+    "\n",
+    "# Objective function\n",
+    "max_vars_func = mdl.sum(x[i] for i in range(1,5))\n",
+    "mdl.maximize(max_vars_func)\n",
+    "\n",
+    "# Constraints\n",
+    "mdl.add_constraint(mdl.sum(i*x[i] for i in range(1,5)) == 3)\n",
+    "\n",
+    "print(mdl.export_to_string())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generate an Ising Hamiltonian from the model using ```docplex.get_qubitops(mdl)```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qubitOp, offset = docplex.get_qubitops(mdl)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Checking that the full Hamiltonian gives the right cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "energy: -57.5\n",
+      "objective: -2.0\n",
+      "solution: [1. 1. 0. 0.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "ee = ExactEigensolver(qubitOp, k=1)\n",
+    "result = ee.run()\n",
+    "\n",
+    "print('energy:', result['energy'])\n",
+    "print('objective:', result['energy'] + offset)\n",
+    "\n",
+    "x = docplex.sample_most_likely(result['eigvecs'][0])\n",
+    "print('solution:', x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Running it on quantum computer\n",
+    "We run the optimization routine using a feedback loop with a quantum computer that uses trial functions built with Y single-qubit rotations, $U_\\mathrm{single}(\\theta) = \\prod_{i=1}^n Y(\\theta_{i})$, and entangler steps $U_\\mathrm{entangler}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "energy: -57.16261789728296\n",
+      "time: 10.59960389137268\n",
+      "solution objective: -1.6626178972829635\n",
+      "solution: [1. 1. 0. 0.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "seed = 10598\n",
+    "\n",
+    "spsa = SPSA(max_trials=300)\n",
+    "ry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')\n",
+    "vqe = VQE(qubitOp, ry, spsa, 'matrix')\n",
+    "\n",
+    "backend = BasicAer.get_backend('statevector_simulator')\n",
+    "quantum_instance = QuantumInstance(backend, seed=seed, seed_mapper=seed)\n",
+    "\n",
+    "result = vqe.run(quantum_instance)\n",
+    "\n",
+    "\"\"\"declarative approach\n",
+    "algorithm_cfg = {\n",
+    "    'name': 'VQE',\n",
+    "    'operator_mode': 'matrix'\n",
+    "}\n",
+    "\n",
+    "optimizer_cfg = {\n",
+    "    'name': 'SPSA',\n",
+    "    'max_trials': 300\n",
+    "}\n",
+    "\n",
+    "var_form_cfg = {\n",
+    "    'name': 'RY',\n",
+    "    'depth': 5,\n",
+    "    'entanglement': 'linear'\n",
+    "}\n",
+    "\n",
+    "params = {\n",
+    "    'problem': {'name': 'ising', 'random_seed': seed},\n",
+    "    'algorithm': algorithm_cfg,\n",
+    "    'optimizer': optimizer_cfg,\n",
+    "    'variational_form': var_form_cfg,\n",
+    "    'backend': {provider': 'qiskit.BasicAer', 'name': 'statevector_simulator'}\n",
+    "}\n",
+    "\n",
+    "result = run_algorithm(params, algo_input)\n",
+    "\"\"\"\n",
+    "\n",
+    "x = docplex.sample_most_likely(result['eigvecs'][0])\n",
+    "print('energy:', result['energy'])\n",
+    "print('time:', result['eval_time'])\n",
+    "print('solution objective:', result['energy'] + offset)\n",
+    "print('solution:', x)"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.6.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/qiskit/aqua/optimization/maxcut_and_tsp.ipynb b/qiskit/aqua/optimization/maxcut_and_tsp.ipynb
index dbd9f213f..91296bd69 100644
--- a/qiskit/aqua/optimization/maxcut_and_tsp.ipynb
+++ b/qiskit/aqua/optimization/maxcut_and_tsp.ipynb
@@ -97,18 +97,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/manoel/Documents/Quantum/qiskit-terra/qiskit/tools/qcvv/__init__.py:13: DeprecationWarning: The qiskit.tools.qcvv package is deprecated. Please use qiskit-ignis available on PIP for similar functionality and more.\n",
-      "  'functionality and more.', DeprecationWarning)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# useful additional packages \n",
     "import matplotlib.pyplot as plt\n",
@@ -145,9 +136,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'IBMQ'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-3-d746f0c97f1a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mqiskit\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mIBMQ\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;31m# IBMQ.load_accounts()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mImportError\u001b[0m: cannot import name 'IBMQ'"
+     ]
+    }
+   ],
    "source": [
     "from qiskit import IBMQ\n",
     "# IBMQ.load_accounts()"
@@ -162,20 +165,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/manoel/anaconda3/envs/QISKitenv/lib/python3.6/site-packages/networkx/drawing/nx_pylab.py:611: MatplotlibDeprecationWarning: isinstance(..., numbers.Number)\n",
-      "  if cb.is_numlike(alpha):\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -204,7 +199,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
@@ -240,7 +235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
@@ -269,7 +264,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -307,7 +302,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -315,6 +310,43 @@
     "algo_input = EnergyInput(qubitOp)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### [Optional] Using DOcplex for mapping to the Ising problem\n",
+    "Using ```docplex.get_qubitops``` is a different way to create an Ising Hamiltonian of Maxcut. ```docplex.get_qubitops``` can create a corresponding Ising Hamiltonian from an optimization model of Maxcut. An example of using ```docplex.get_qubitops``` is as below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from docplex.mp.model import Model\n",
+    "from qiskit.aqua.translators.ising import docplex\n",
+    "\n",
+    "# Create an instance of a model and variables.\n",
+    "mdl = Model(name='max_cut')\n",
+    "x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}\n",
+    "\n",
+    "# Object function\n",
+    "maxcut_func = mdl.sum(w[i,j]* x[i] * ( 1 - x[j] ) for i in range(n) for j in range(n))\n",
+    "mdl.maximize(maxcut_func)\n",
+    "\n",
+    "# No constraints for MaxCut problems."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qubitOp_docplex, offset_docplex = docplex.get_qubitops(mdl)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -324,7 +356,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
@@ -339,7 +371,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XlclWX+//HXdVhFQFTcN1wrK/Nb6pgtU1PNODZftXLKyq8L9gt1mlIrK52sNJXMBRUUUNAsGzNzy5y0srLSFiW1XHNFUEcRRFQQ4Vy/P24wRJYDnHPus3yejwcPz3Jz358r7X2ucy+fW2mtEUII4V0sZhcghBDC+ST8hRDCC0n4CyGEF5LwF0IILyThL4QQXkjCXwghvJCEvxBCeCEJfyGE8EIS/kII4YV8zS6gPOHh4ToiIsLsMoQQwq1s27YtQ2vdoLLlXDb8IyIi2Lp1q9llCCGEW1FKHbVlOZcNf+FdCgogNRXOnweLBRo0gIYNQSmzKxPCM0n4C9NkZ8Pq1bBsGezfbwS9xQJaGx8GtWtDly4wcCDceSf4+JhdsRCeQ8JfON2lSzB7NixYAIWF4OcHwcFG8Bcr/gDYtAm++Qbq1YPoaLjnHtPKFsKjyNk+wqn27YOePSE+HmrVgrAwY4ZvKfUvUSnjQ6FOHQgNhXPnYOhQGDkSLl40p3YhPImEv3CanTvhkUcgLQ3q1gXfKnzvDAoyPgg+/hgGDIALFxxXpxDeQMJfOMWxY0ZoFxQYIV4dFovxTWHHDhg2DKxW+9YohDeR8BcOZ7XC6NHG7prg4JqtSynjA2DzZli61D71CeGNJPyFw330EaSkVH/GX5pSxnGCiRPh1Cn7rFMIbyPhLxzKaoU5cyAgoOJz9jMzl3H48P+xd+/tHD/+eqXr9feH/HzjNFEhRNVJ+AuH2roVTp40zuypiK9vOOHhQ6lTp7fN6w4KgqQk4ziCEKJq7BL+SqlkpdQppdSv5byvlFKzlVIHlFI7lVK32mO7wvVt3gyXL1d+pW5o6J8ICbkHHx/b9w0FBBjHEQ4dqmGRQnghe838FwE9K3j/r0D7op+ngXl22q5wcd9/b4S0o2gNe/Y4bv1CeCq7hL/WehOQWcEifYDF2vA9EKaUamKPbQvXdvCgsX/eUfLzjW0IIarGWfv8mwHHSjxPK3pNeLj8/Guv3i1PYWEhZ89mkZ19losXbbuKy2KRC76EqA6XOuCrlHpaKbVVKbX19OnTZpcj7MDf37aLsQoLC0lNPYqPjw8BAQEcP36Co0ePcOHCeUCX+3tWa+UHk4UQ13JW+KcDLUo8b1702lW01ola6y5a6y4NGlR6LwLhBtq0MWb/FSksLODo0UMEBfkRElKbwMAA2rRpQZ06ofz3v//l8OHD5OTkUNaHgL8/tG3rmNqF8GTOCv81wMCis366A9la6xNO2rYwUbduRhfP8hQWFpCamgqsJjPzIc6ceYfs7HXs23cHly8vp02bNoSHh5ORcZpDhw5x7lw2JT8ElIIbbnD4MITwOHZp6ayU+jdwDxCulEoDXgP8ALTW8cA6oBdwALgIDLHHdoXru/NOo4On1tee7mnM+FMJDg6mYcPngRfKXEdISCghISGcP3+BM2cyOHXqNOHh9QkMrEOtWhbatXP8OITwNHYJf63145W8r4F/2GNbwr107QqNGkFmpnFRVjEj+I8SEhKCsYuvslt2KYKDgwkODubixQtkZGRw/Hguf//7SQoLb8TX14HnkwrhgVzqgK/wPBYLPPOMsetHF+2tqXrwXy0oqDaNG7eiceP61Kq1ht69e7N48WIuSqN/IWwm4S8c7tFHoVMn47aNBQU1C34wPkQuXIDXXgsgPv514uLi2Lt3L7179yYxMZFz587ZfxBCeBgJf+FwFgvMnAl+fgUcOnSSkJBQGjRoSHWD/+xZY3fS//2f8Vq7du2YPHkyycnJnDx5kr59+zJ79mwyMyu67lAI7ybhL5wiNDST5s3HUbt2bQICqncar9UKWVnQsSPMn3/txWMtW7Zk/PjxLFmyhLy8PPr168fUqVM5efKkHUYghGeR8BcOd+bMGaKionj00XZ8/nldGjY0Zu+FhbavIzfX2G3Us6dxE5eQkPKXbdKkCWPGjOHDDz8kMDCQJ554gokTJ3Ls2LHyf0kIL6O0Lv/qSTN16dJFb9261ewyRA1lZGQwbNgwevbsyVNPPQUYQT59OixebMzm/f0hMPDamXxBgdG1U2vjRjCTJ8MDD1TeIbS07Oxsli5dyrJly+jevTuRkZG0lSvDhIdSSm3TWnepdDkJf+EoGRkZREVF8eCDDxIZGXnN+5mZsGKFcUOWQ4fAx+f3D4CCAvDzg9tug0GD4J57qnbD97JcuHCB5cuXs2TJEjp16kRkZCQdO3as2UqFcDES/sJUp0+fJioqir/97W9lBn9p+flw+DCcP298AISHQ/PmVZ/l2yIvL49Vq1axePFi2rRpQ2RkJLfeKreYEJ5Bwl+Y5tSpUwwbNozevXszePBgs8spV35+PuvWrWPhwoU0bNiQyMhIunfvjnLEJ44QTiLhL0xx6tQpoqKieOihhxg4cKDZ5diksLCQDRs2sHDhQgICAhg6dCh33303Flt7UQvhQiT8hdO5Y/CXZLVa+eqrr0hOTiY/P5/IyEgeeOABfHx8zC5NCJtJ+Aun+u9//0tUVBT9+vVjwIABZpdTI1prtmzZQnJyMhkZGQwePJgHH3wQPz8/s0sTolIS/sJpTp48WXQe/6M8+eSTZpdjVykpKSQlJXHkyBEGDhxI3759CXDkTYmFqCFbw192aooaOXHiBFFRUTz22GMeF/wAt956K3Fxcbz99tv8+OOP0kROeAwJf1FtxcHfv39/nnjiCbPLcaiOHTsyffp0aSInPIaEv6iW48ePExUVxRNPPMHjj1d4OwePIk3khKeQ8BdVdvz4cYYNG8aAAQPo37+/2eWYQprICXcn4S+qJD09naioKAYMGMCjjz5qdjmmkyZywl1J+AubFQf/oEGDJPhLqV+/Ps8++ywrV66kYcOGDB48mHHjxnHw4EGzSxOiTBL+wiZpaWlERUUxZMgQ+vXrZ3Y5LqtOnTpERUWxZs0aOnTowPDhw3nhhRfYvXu32aUJcRU5z19U6tixYwwbNoyhQ4fy8MMPm12OW5EmcsLZ5CIvYRepqakMHz6cp556ioceesjsctyWNJETziLhL2osNTWVYcOG8fTTT9O3b1+zy/EIJZvIBQYGEhkZKU3khF1J+IsaOXr0KMOHD7/SmlnYlzSRE44i4S+qTYLfeUo3kRsyZAi9evWSJnKi2iT8RbUcOXKEESNGMHz4cP73f//X7HK8ijSRE/Yg4S+q7PDhw4wYMYJnnnmGBx980OxyvNauXbtISkpi165dPPnkk/Tr14+goCCzyxJuQrp6iio5dOgQI0aM4J///KcEv8luvPFGZsyYIU3khENJ+Iurgr9Xr15mlyOKSBM54UgS/l7u4MGDjBgxgpEjR0rwuyhpIiccQcLfix04cIARI0YwatQoevbsaXY5ohLSRE7Yk4S/l/rtt9/4xz/+wfPPP89f/vIXs8sRVSBN5IQ9SPh7of379/PMM8/w/PPP8+c//9nsckQ1SRM5URNyqqeXKQ7+MWPGcP/995tdjrAjaSInQM7zF2UoDv6XXnqJ++67z+xyhINIEznvJuEvrrJ3716effZZXn75Zf70pz+ZXY5wAmki550k/MUVxcH/yiuvcO+995pdjnAyaSLnXST8BQB79uzhueeeY+zYsdxzzz1mlyNMJE3kvINT2zsopXoqpfYppQ4opV4u4/3BSqnTSqntRT9P2WO7omK7d+/mueeeY9y4cRL8AqUUPXr0YMGCBYwfP54NGzbQt29fPvjgAy5dumR2ecLJajzzV0r5APuBB4A04Cfgca317hLLDAa6aK2fsXW9MvOvmd27dzNy5Ej+9a9/cffdd5tdjnBR0kTO8zhz5t8NOKC1PqS1zgeWAn3ssF5RTbt27eK5556T4BeVkiZy3sse4d8MKHl9eVrRa6U9opTaqZRarpRqUdaKlFJPK6W2KqW2nj592g6leZ9ff/2VkSNHMn78eAl+YTNpIud9nHXO18dAhNa6E/AZ8E5ZC2mtE7XWXbTWXRo0aOCk0jzHzp07GTVqFK+//jp33XWX2eUINyRN5LyHPcI/HSg5k29e9NoVWuszWuviI0oLgNvssF1Rws6dO3n++ed54403uOOOO8wuR7g5aSLn+ewR/j8B7ZVSrZVS/kB/YE3JBZRSTUo87Q3sscN2RZEdO3ZcCf4ePXqYXY7wIGU1kfvXv/4lTeQ8QI3DX2tdADwDrMcI9WVa611KqQlKqeK7fz+rlNqllNoBPAsMrul2hWH79u288MILTJgwQYJfOEzJJnLt2rWTJnIeQC7ycmM///wzY8aMYeLEiXTv3t3scoQXkSZyrkuu8PVwKSkpjBkzhsmTJ9OtWzezyxFeKj8/n08++YRFixZJEzkXIeHvwVJSUnjppZeYNGmSBL9wCdJEznVI+Huobdu28dJLLzFlyhS6du1qdjlCXEWayJlPwt8Dbd26lZdffpno6Gi6dKn071YI00gTOfNI+HuYn376ibFjxxIdHc1tt8llEsJ9pKSkkJSUxJEjRxg4cCB9+/YlICDA7LI8loS/B/nxxx8ZO3YsU6dOlTMqhNuSJnLO4dSWzsJxfvzxR8aNGyfBL9yeNJFzLRL+Luz777+XGb/wONJEzjVI+LuoLVu28OqrrzJt2jT+53/+x+xyhLA7aSJnLgl/F7R582bGjx/PtGnT6Ny5s9nlCOFQ0kTOHBL+Lmbz5s289tprTJ8+nVtuucXscoRwGmki51wS/i7ku+++uxL8nTp1MrscIUwhTeScQ071dBHffPMNEyZMYMaMGdx8881mlyOEyyjZRK5t27ZERkbKcbAKyHn+bmTTpk28+eabzJw5kxtvvNHscoRwSdJEzjYS/m5i06ZNTJw4kVmzZtGxY0ezyxHC5UkTuYpJ+LuBr7/+mkmTJhETEyPBL0QVlW4iN3ToUB544AGv/xCQ8HdxX375JVOmTGHWrFnccMMNZpcjhNsqbiKXlJREZmYmgwcP9uomchL+Lmzjxo1ER0cze/Zsrr/+erPLEcIjaK35+eefvb6JnIS/i5LgF8LxvLmJnDR2c0FffPEF0dHRzJkzR4JfCAeSJnKVk/B3ks8//5y33nqL2NhYrrvuOrPLEcIrSBO58kn4O8GGDRuYOnUqsbGxdOjQwexyhPA60kTuWrLP38E2bNjA9OnTiY2NpX379maXI4QAzpw5w5IlS1i1ahX33nsvgwcPpkWLFvbdyNmzsGcP7N0LWVnGaw0bwvXXGz/BwfbdXhE54OsCPv30U2bOnElcXBzt2rUzuxwhRCnZ2dksXbqUZcuWcfvttzNkyBDatm1b/RVarfDttzB/PmzZAr6+kJ8PWhs/Pj7g5weFhXD//RAZCV26gB2vUpbwN9l//vMfZs2aRVxcXM3+MQkhHO7ChQt8+OGHvP/++3Tq1InIyMiqX3h59CiMGgW//GI8DwmB8i44s1ohO9sI/T/+EaKjoUGDmg2iiIS/idatW8fs2bOZO3cubdq0MbscIYSNqt1Ebu1aeOEFKCiAOnVsn8lrbXwIBAUZ3xb+8IeaDQAJf9N88sknzJkzR4JfCDdWpSZyq1YZwV+rFlT3grKLF41dQYsWwe2316h2CX8TrF27lri4OObOnUvr1q3NLkcIUUOVNpH79Vd4+GEj9Gt6JfHFi8Y3hg0boFmzaq9Gwt/JPv74Y+bOncu8efOIiIgwuxwhhB2V2UTuj3/E0qsXpKVBaKh9NnT2LHTtCkuWlH+8oBIS/k60Zs0a4uPjmTt3rgS/EB6sZBO5W7ZvJzI9naBmzbDY62yd4mMA8fHG2UDVIO0dnGT16tXEx8fLjF8IL6CUokePHixITCTy8mXO5edz8MABMrOysJYzkT5XWMgLaWncuXcvfztwgE+zsyvagDHjT0x00Ah+5+vwLXiwVatWkZiYSHx8PC1btjS7HCGEk6iUFILz8ghu3ZrcvDwyMjLIyMigXr161K1bF58Su2yiT57ETyk2dOjA/rw8njt2jA6BgbQp7xhBSAikpBi7k5o3d9gYZOZfTStWrJDgF8Jbbd9unNapFLVq1aJFixa0bNmSvLw8Dhw4wOnTpyksLCTXamVjTg7DGzQgyGKhc1AQfwwJ4RNbZv87dzp0CBL+1bBixQqSkpJISEiQ4BfCG/3wg3H1bgmBAQE0b9aMiIgILhcUcODgQVJOnMCiNS39/a8s1z4ggEOXLlW8/suXHR7+3rfbJyfH+IvbudP4apWTY1xy3aqVcZS9c2e44YZyL9JYvnw5CxcuJCEhgeYO/EomhHBh6elGm4YSNMYBYR8fH8LDwwkNDeXQqVOovDyOpqbSokULLEoRbLFwwWqteP1+fnDkiMPKB28K/9RU4yDKRx8Zl1bn54O/vxH8WhsfBmvWGF+3WreGYcOgTx/j/SIffvgh77zzjgS/EG5Ia01+fj65ubnk5eWRm5t75XHx89Kvl36/+Pk/duygzoULXFIKbbVi1Rqr1YpSCovFgkUplMWCn9bkKUVWVhbNmjbF4uvLBauV2racxlnZB0QNeX74W63GVXNvvWXsowsJuebr2lW0hmPH4MUXjd+LiYE2bVi2bBmLFy8mISGBZjW4AEMIUTatNZcvX74mfMsL4KqGd15eHr6+vgQGBhIYGEitWrWu/Fn8U/q90NBQGjVqdNVrgYGBtDx0iMCDB1G1a2OxWFAWi/FnqTHVz82lcN8+fJs3x7cod/ZfulT+wd5ihYVGmwgHskv4K6V6ArMAH2CB1jq61PsBwGLgNuAM8JjW+og9tl2h3FwYPhy++QZq1zaCvzJKGcsGBcHu3fDgg2z8+9959+efSUxMpGnTpg4vWwhXVDKcbZkhVzZ7Lh3eeXl5+Pj4XBPCpUO65HuhoaE0bNiw3PAu/bpPiW/yNXLvvfDbb8beg3LkXbrE6bQ07gsN5f28PF61Wtmfl8fXOTkstOW0cFt6CtVAjcNfKeUDxAEPAGnAT0qpNVrr3SUWGwpkaa3bKaX6A28Bj9V02xXKz4enn4bvvoO6daveMlUpCAvj7MmTXDdjBgvffZdwCX7hworDuSYz5MqCvaxwLiuki98PDg6mQYMG5YZ36d+xWzg72i23XLPPv6S8S5dITU2lUaNGvFa7Nm8cP84D+/dTx8eHVxo3rnzm7+tr9Px3IHvM/LsBB7TWhwCUUkuBPkDJ8O8DvF70eDkQq5RS2pGXF8+ZU/3gL3ImM5PM8+eJaNoUv1dfhR49oFEjOxcqvEXpcLZ1/3Jl4V3yPYvFUmnIlg7n8PDwcsO79OtuE86OdscdRq4UFFyzGzkvL4/UY8do3KgRoUVtH6ZX5UYxeXnGjV46dbJnxdewR/g3A46VeJ4GlO5LemUZrXWBUiobqA9k2GH719q1y7g8OjS0ZsGfmUmrVq3w8/Mzem68/DIkJ9v1xgvCdZQM55rOkMsL7+Jwrixkix8HBQVRv379Cnd9lPzTt6LjWcJ+6tSBvn1h+XJjglkkLy+P1NRUGjdufCX4qyw3F0aMqPjYpB241L8UpdTTwNNAzc6fnzzZOHBbzf94ZzIzycrMJKI4+MH4y/72W/j5Z7j11urXJqpNa01BQYFdZsjlhbfFYqk0ZEs+DgoKol69etccNCwv2CWcPcjw4UY756IzB68Ef5MmhNpyfLEsubnGrL9/f/vWWgZ7/EtMB0p+p2le9FpZy6QppXyBOhgHfq+itU4EEsFo7FatalJTjfP4K/nUzbdaiT55kh8vXuRcYSHN/fx4pmFDrrt0iaysrN9n/MWUMj5QFi6U8K9AyQOC9ti9Ufo9VXRFpS37kIt/6tatW+m+6eLXJZyFzSIijLMCp0wht7CQY8eO1Sz4rVa4dAlmzIB69exaalns8S/9J6C9Uqo1Rsj3B54otcwaYBCwBegHbHTY/v5PPjH+I1ZyHm0h0NjPj8SWLWns58d358/z/JEjTPP3p1ubNviVFQIhIfDpp8anc61aDinf0YpnzvY6fa7061prm2bBJd+rW7euTWd2BAYGXv2BLITZhgzh7Nq1XFy/nsYtWtQs+M+eNWb8f/6zfWssR43Dv2gf/jPAeoxTPZO11ruUUhOArVrrNUAS8K5S6gCQifEB4RhbtlR4FL5YLYuFp0vcM/OG/HzqW61caNCg7OAH44IvHx/jFC8HHYwpuVujJjPk8sK7ZDjbunujZDhXNnuWcBbeZPe+fYzJyWHB3XcT+ttvZR4ArlR+Ply4YNwUZuJEpx1TtMt3XK31OmBdqdfGl3icB/zdHtuq1K+/QmBglX4lIyODI1lZnPHzo0NQUIXLWgsKyN++nZwmTRyye8Nqtdq8i6L4cVhYmM0Xrvj6+pZ9KzohRJXs3r2bkSNH8q/XXqPx7bfD3LkQG2vsHg4NrfxmLIWFcO6cca3AhAnw+OPVvoFLdXjezVzatjUOztr4H/F0RgZpJ04w08eHpr6+/CMoCKvVetUl29pqxVr0vM7lyyxp2ZLP27QpN6CrGt4l3/Pz85NwFsLF7dq1i5EjR/Lqq69y9913//7Gnj0wbRps2vT77ufAQOPbgNbGN4O8PGNZiwX++lfj/r9VORW0ErbezMXzjm5VMTj9/P2ZW9RD45/16hFSdLl2cW+O4sfFl3CrM2d48aWXePGppxxRvRDCxf3666+MGjWK8ePHc9ddd1395g03QFISHD8O69f/3kQyO9vIprp1jRNGuneHv/zFKQd2y+N54R8W9nvTtkporZl1/jwqLIy369Qh58wZ8vPyjIteate+pk8HYHyCh4XZvWwhhOv75ZdfGD16NK+//jp33HFH+Qs2bQpDhhg/Lsrz+vnfdNPvX6sqMeXkSQ7n5xPTogWNwsJo27Yt9evV4/SpUxw+fJhz585xzU4xHx+HX3YthHA9O3fuZPTo0bzxxhsVB7+b8LyZf48exv62Spy4fJkVZ8/irxR/+e23K6+PbdyYnm3acP78eTIyMjh1+jTh4eHUCQ1FWa3Gfrv27R05AiGEi9mxYwcvvPACb7zxBj169DC7HLvwvPDv1QvefrvSc/2b+Pmx9YYbyn0/JDiY4OBgLl64QEZGBqdPn6ZJQAC1+vfHp7KmTEIIj7F9+3ZefPFFJkyYwO233252OXbjebt9mjc3Zv/nztV4VQqoXbs2rVq1olnTpuReusQ/t25lyZIl5Obm1rxWIYRL+/nnn3nxxReZOHGiRwU/eGL4A4wbZ8z6L1+22yqD8vNp8NhjPJeUxM6dO+nduzdJSUnk5OTYbRtCCNeRkpLCiy++yKRJk+jevbvZ5didZ4Z/hw7w3HPG/XntcR3DxYvGDV4mT+a666/nrbfeIjExkaNHj9K3b1/mzp1LVlZWzbcjhHAJKSkpjBkzhsmTJ9OtWzezy3EIzwx/gKgouO8+yMqq2QfAxYvGlXjz50P9+ldebt26NRMmTGDx4sWcPXuWRx55hBkzZnDq1Ck7FC+EMMu2bdt46aWXmDJliscGP3hy+Pv6QlyccSHF2bNGt7yq0Nr4PaXgnXegnH8EzZo1Y+zYsSxduhSA/v37M3nyZI4fP17TEQghnGzr1q1Xgr9r165ml+NQnhv+YFzoFRcHU6YYl1VnZRkXgFVEa2N3UXY2dOliXKVnw/6+hg0bMnr0aD766CPCwsIYMGAA48eP5/Dhw3YajBDCkX766SdeeeUV3nrrLbp0qbQ7gtvzvN4+5TlxwpjBv/eecSD48uXfu3RqbTwv7r9x000wbBg88EC1Gy3l5OSwbNkyli5dyq233kpkZCTXXXed/cYjhLCbH3/8kbFjxzJ16lRudfP7ddja28d7wr9YXh6kpBi3ekxJMU4J9fWFVq3gttuMVs2tW9ttcxcvXmTlypW89957dOjQgaFDh9LJwffmFELY7ocffmDcuHEeEfwg4e9y8vPz+fjjj1m0aBHNmjUjMjKSrl27SgdPIUz0/fff8+qrr/L222/TuXNns8uxCwl/F1VQUMCnn37KwoULCQkJYejQodx5553yISCEk23ZsoXx48czbdo0brnlFrPLsRsJfxdntVr54osvWLhwIQBDhgzhvvvuw+LEmzkI4a02b97Ma6+9xvTp0z1uN6yEv5vQWvPtt9+SnJzMuXPnGDx4MH/961/lRuJCOMh3333H66+/7pHBDxL+bkdrzdatW0lKSiI9PZ1BgwbRu3dv/G24L4EQwjbffvstb7zxBjNmzODmm282uxyHkPB3Yzt37iQ5OZl9+/YxYMAAHn74YWrVqmV2WUK4tW+++YYJEyYwc+ZMbrrpJrPLcRhbw192MLugTp06ERMTQ0xMjDSRE8IONm3axIQJE4iJifHo4K8KCX8Xdt11111pIpeamkqfPn2Ii4uTJnJCVMHXX3/Nm2++yaxZs7jxxhvNLsdlSPi7gdatW/PGG2/w3nvvce7cOWkiJ4SNvvrqKyZNmkRMTAwdO3Y0uxyXIuHvRpo2bcorr7wiTeSEsMGXX37J5MmTmTVrlgR/GST83ZA0kROiYhs3bmTKlCnMnj2bGyq4Xas3k/B3Y3Xr1mXEiBGsXr2aiIgIoqKiGDNmDPv27TO7NCFM88UXXxAdHc2cOXO4/vrrzS7HZcmpnh4kNzeXlStX8u6770oTOeGVPv/8c6ZOnUpsbCwdOnQwuxxTyHn+Xqy4idw777xDkyZNGDp0qDSREx7vs88+Y9q0acyZM8drgx8k/AXXNpGLjIzkrrvukg8B4XE2bNjA9OnTiY2NpX379maXYyoJf3GF1Wpl48aNJCcno7VmyJAh3H///dJETniE9evXM2PGDOLi4mjXrp3Z5ZhOwl9cQ2vNd999R1JSEtnZ2QwZMkSayAm39umnnxITE0NcXBxt27Y1uxyXIOEvylXcRC45OZm0tDRpIifc0rp165g9ezZz586lTZs2ZpfjMiT8hU2Km8jt3bv3ShO5oKAgs8sSokLr1q1jzpw5xMXFSfCXIo3dhE2Km8jNnj2bX3/9lT59+rBgwQJpIidc1tq1a5n6+sCLAAARHklEQVQzZ47M+GtIwl8A0KFDB6Kjo5k/fz7Hjh2TJnLCJX388cfExcUxb948WrdubXY5bk3CX1wlIiJCmsgJl7RmzRrmzZtHfHw8ERERZpfj9iT8RZnKayKXnp5ucmXCG61Zs4b4+HjmzZtHq1atzC7HI0j4iwqVbiI3cOBAxo8fz6FDh8wuTXiJVatWER8fT3x8vAS/HdUo/JVS9ZRSnymlfiv6s245yxUqpbYX/aypyTaFOYqbyK1atYqIiAiGDRsmTeSEw61YsYL58+cTHx9Py5YtzS7Ho9ToVE+l1FQgU2sdrZR6GairtX6pjOXOa62Dq7JuOdXTtZVsIte+fXueeuopaSIn7GrFihUkJSURHx9PixYtzC7HbTjlPH+l1D7gHq31CaVUE+ArrfV1ZSwn4e+h8vPzWbt2LYsWLZImcsJuPvroIxYuXEh8fDzNmzc3uxy34qzwP6u1Dit6rICs4uellisAtgMFQLTWelVl65bwdy8FBQWsX7+ehQsXUrt2bYYOHSpN5ES1fPjhh7zzzjskJCTQrFkzs8txO3YLf6XU50DjMt4aB7xTMuyVUlla62v2+yulmmmt05VSbYCNwH1a64NlLPc08DRAy5Ytbzt69Ghl9QsXI03kRE0sW7aMd999l/j4eAn+anKp3T6lfmcRsFZrvbyi5WTm796Km8glJydz9uxZaSInKvXBBx+wZMkS4uPjadq0qdnluC1ntXdYAwwqejwIWF1GIXWVUgFFj8OBO4DdNdyucHFKKe68806SkpIYO3Ys69at46GHHuLDDz8kPz/f7PKEi1m6dKkEv5PVdOZfH1gGtASOAo9qrTOVUl2AYVrrp5RSPYAEwIrxYROjtU6qbN0y8/c8v/zyC8nJyezZs0eayIkr3n//fZYuXUpCQgJNmjQxuxy3J109hcvav38/ycnJbNu2jccee4zHHnuMkJAQs8sSJnj//ff54IMPSEhIoHHjsg4tiqqSrp7CZZVsIpeWliZN5LzUe++9x7Jly0hMTJTgN4GEvzBNREQEr7/++lVN5KZPny5N5LzAu+++y/Lly0lISKBRo0Zml+OVJPyF6YqbyH3wwQdYLBZpIufhFi9ezIoVK0hMTJTgN5GEv3AZDRo0YNSoUaxYsUKayHmoRYsWsWrVKhISEmjYsKHZ5Xg1CX/hcsLCwhgxYgSrV6+WJnIeZOHChVdaM0vwm0/CX7is4OBgIiMjWb16NZ07d2bkyJE8++yz7Nixw+zSRBUlJyezdu1amfG7EDnVU7gNaSLnnpKSkli3bh0JCQmEh4ebXY7Hk/P8hceSJnLuY/78+axfv56EhATq169vdjleQcJfeDyr1cqXX35JUlISVquVyMhIaSLnQhITE/nss8+Ij4+X4HciCX/hNUo3kRs8eDC9evWSJnIm0VqTmJjIF198QXx8PPXq1TO7JK8i4S+8jtaabdu2kZSURFpaGgMHDqRPnz74+/ubXZrX0FqTkJDAxo0bJfhNIuEvvFrJJnJPPvkkjzzyiDSRczCtNfHx8Xz11VfMmzdPgt8k0ttHeLWbb76ZmTNnMnv2bHbv3k2fPn1YsGABOTk5ZpfmkbTWzJs3j6+//lpm/G5Cwl94tA4dOjBlypSrmsjFxsaSmZlpdmkeQ2tNXFwc33zzDfHx8dSte83N/IQLkvAXXqFkE7mcnBz69esnTeTsQGtNbGwsmzdvZt68eYSFXXMLb+GiJPyFVymridykSZNIS0szuzS3o7Vmzpw5bNmyRYLfDUn4C69UsolcvXr1GDRokDSRqwKtNbNmzeKHH35g3rx51KlTx+ySRBVJ+AuvFhYWxvDhw69pIrd3716zS3NZWmtiYmLYunWrBL8bk/AXgmubyI0aNUqayJVBa83MmTNJSUlh7ty5hIaGml2SqCY5z1+IMpRsIte4cWOGDh1Kt27dvLp/kNaaGTNmsGPHDmJjYyX4XZRc5CWEHRQWFrJ+/XqSk5OvNJG78847va5/kNaaadOm8csvvxAXF0dISIjZJYlySPgLYUfe3EROa83bb7/Nrl27iIuLIzg42OySRAUk/IVwAK01mzdvJikpySuayGmtmTp1Knv27CE2NlaC3w1I+AvhQMVN5JKTk0lNTb3SRC4gIMDs0uzGarUydepU9u3bR2xsLLVr1za7JGEDCX8hnOSXX35h4cKF7N6922OayFmtVqKjozlw4ABz5syR4Hcj0thNCCe5+eabmTFjxlVN5ObPn8+5c+fMLq1aioP/4MGDMuP3YBL+QthJySZy6enp9O3b1+2ayFmtViZPnsyhQ4eYM2eO23+DEeWT8BfCzko2kTt//jz9+vVj2rRpLt9Ezmq1MmnSJI4ePcrs2bMl+D2chL8QDtK0aVNefvllli1bhq+vr9OayOXlQWYmZGVBQYFtv2O1WnnzzTc5duwYs2bNkuD3AnLAVwgnOXv2LP/+979Zvnw5PXr0YMiQIbRp06bG67Va4dtvYcUK2LoVjh8HH5/f32/XDnr0gMcegw4dyvp9KxMnTiQ9PZ2YmBgJfjcnZ/sI4aLOnz/PsmXLWLp0KZ07dyYyMpLrr7++yuvRGlatguhoY5ZfWAi1akFAABR3obBajW8Cly4Zr918M0yYYPxpvG9lwoQJnDhxgpiYGGrVqmXHkQozSPgL4eJyc3NZuXIl7733Hu3atSMyMpLOnTvb9LunT8MLLxgz/sBAI/QrozUUn4AUFQXPPmvlzTdf59SpU8TExBAYGFjtsQjXIeEvhJuoahO59HR49FE4eRLCwn6f5duqoADOndPUqbONrl0XMXv2NAl+DyLn+QvhJvz9/Xn44YdZuXIlffv2Zdq0aQwaNIhNmzZhtVqvWjY729h3f+oU1K1b9eAH8PXVXLx4nIMHW+HjE0NAgAS/N5LwF8JF+Pj40KtXLz744AMGDx5MfHw8TzzxBBs2bLjyIfDaa3DiBFT//ima9PTjWK0FtG1bn88+82XtWrsNQbgR2e0jhIsq3USua9fRLFhwB3XqKKrXTFSTnp5OYaGVFi2ao5SFvDzj28PXX0O9evYegTCDrbt9PLMVoRAeQCnFHXfcQY8ePUhJSeHvf/fh1Kl0IIiwsDCUKvsTID39VS5e/BGrNRdf33Dq1x9IWFifa4IfjIPFZ8/CRx/B//t/ThycMJ2EvxAuTilFaOht+PhAy5a5nDmTQUZGBvXq1adu3TAsFp+rlg8PH4Kf36tYLP5cunSEo0efJju7DhZL26uCv1hgIMyfD5GRV18fIDxbjfb5K6X+rpTapZSyKqXK/ZqhlOqplNqnlDqglHq5JtsUwhtt2mScxx8UVIsWLVrQokVL8vJyOXDgIBkZpyksLLyybEBAGywWf8A4vfPSpUsUFBynefNrgx+M8M/OhgMHnDYc4QJqesD3V+BhYFN5CyilfIA44K9AR+BxpVTHGm5XCK/y449Xz8oDAwNp1qw5ERGtyM+/zMGDBzh16r8UFPVzOHkymr1772Dfvt4oVZeIiD7l7iYC40Nizx5Hj0K4khrt9tFa7wEqu6l1N+CA1vpQ0bJLgT7A7ppsWwhvsmePMUMvzd8/gKZNm3L5cj5nzpzh0KGD1KlTh/r1R3P58uP4++8hJOQYFkvFp3Nevmxso29fBw1AuBxnnOrZDDhW4nla0WtCCBvl5lZ8Tr+fnz+NGzcp6hWkOHLkCEpZaN36zxQUnCYra3mF67dYICfHvjUL11bpzF8p9TnQuIy3xmmtV9uzGKXU08DTAC1btrTnqoVwa35+Rn+eyvj6+tGoUSMaNWoIFH9aFJKfX3EnUa3B37/GZQo3UunMX2t9v9b6pjJ+bA3+dKBFiefNi14ra1uJWusuWusuDRo0sHH1Qni+li0hP7/y5QoKMjl3bgNWay5aWzl/fgvZ2eupXbtbhb+nlNH9U3gPZ5zq+RPQXinVGiP0+wNPOGG7QniMP/wBfvgBgoMrW1KRlbWcEycmA1b8/JrQqNHzhITcXeFv+fnBDTfYq1rhDmoU/kqph4A5QAPgE6XUdq31X5RSTYEFWuteWusCpdQzwHrAB0jWWu+qceVCeJE//AF8bfi/1de3Lq1aJVZp3QUFxsxfwt+71PRsn5XAyjJePw70KvF8HbCuJtsSwpt17260Xzh/3rb2zVWRk2M0i5N7uHgXaewmhBuwWGDYMOPGLPZsx1VYaKx78GD7rVO4Bwl/IdzEgAHGQdniG7LYQ06OEfxl3d5ReDYJfyHchJ8fzJplXOmbl1fz9WVnQ/PmMHp0zdcl3I+EvxBu5PrrYd4847TPixertw6tjU6e9erB++/b/xiCcA8S/kK4mXvvhUWLjG8CZ88aN2m31eXLxoy/fXvj5u9NmzqsTOHiJPyFcEM9esCXX8Kf/2zst8/KMoK9LFob7SHOnjV2F40eDR9/DE2aOLdm4Vqkn78QbqpePZg7F/bvh3ffhZUrjV1BPj7GtwGljJ/Ll6FxY+PA7iOPyB27hEFu4yiEh9Aajh+HffuM6wEsFqhf37h4KyzM7OqEs8htHIXwMkpBs2bGjxCVkX3+QgjhhVx2t49S6jRw1Ow6qikcyDC7CCfytvGC943Z28YL7jvmVlrrStsiu2z4uzOl1FZb9rl5Cm8bL3jfmL1tvOD5Y5bdPkII4YUk/IUQwgtJ+DtG1Rqquz9vGy9435i9bbzg4WOWff5CCOGFZOYvhBBeSMLfDpRS9ZRSnymlfiv6s24Fy4YqpdKUUrHOrNGebBmvUqqzUmqLUmqXUmqnUuoxM2qtKaVUT6XUPqXUAaXUy2W8H6CU+qDo/R+UUhHOr9J+bBjvaKXU7qK/0y+UUq3MqNOeKhtzieUeUUpppZRHnAEk4W8fLwNfaK3bA18UPS/PRGCTU6pyHFvGexEYqLW+EegJxCil3KrJgFLKB4gD/gp0BB5XSnUstdhQIEtr3Q6YCbzl3Crtx8bx/gx00Vp3ApYDU51bpX3ZOGaUUiHAc8APzq3QcST87aMP8E7R43eAvmUtpJS6DWgEbHBSXY5S6Xi11vu11r8VPT4OnAIqvfDExXQDDmitD2mt84GlGGMvqeR/i+XAfUop5cQa7anS8Wqtv9RaF99J4HuguZNrtDdb/o7BmLS9BdjhNjquQcLfPhpprU8UPT6JEfBXUUpZgOnAC84szEEqHW9JSqlugD9w0NGF2Vkz4FiJ52lFr5W5jNa6AMgG6julOvuzZbwlDQX+49CKHK/SMSulbgVaaK0/cWZhjiaN3WyklPocaFzGW+NKPtFaa6VUWadQjQDWaa3T3GFiaIfxFq+nCfAuMEhrXYXbjghXppQaAHQB/mh2LY5UNGmbAQw2uRS7k/C3kdb6/vLeU0r9VynVRGt9oijsTpWx2O3AXUqpEUAw4K+UOq+1ruj4gGnsMF6UUqHAJ8A4rfX3DirVkdKBFiWeNy96raxl0pRSvkAd4IxzyrM7W8aLUup+jEnAH7XWl5xUm6NUNuYQ4Cbgq6JJW2NgjVKqt9barXvOy24f+1gDDCp6PAhYXXoBrfWTWuuWWusIjF0/i101+G1Q6XiVUv7ASoxxLndibfb0E9BeKdW6aDz9McZeUsn/Fv2Ajdp9L56pdLxKqf8BEoDeWusyP/TdTIVj1lpna63DtdYRRf/vfo8xdrcOfpDwt5do4AGl1G/A/UXPUUp1UUotMLUyx7BlvI8CdwODlVLbi346m1Nu9RTtw38GWA/sAZZprXcppSYopXoXLZYE1FdKHQBGU/GZXi7NxvG+jfHN9cOiv9PSH4ZuxcYxeyS5wlcIIbyQzPyFEMILSfgLIYQXkvAXQggvJOEvhBBeSMJfCCG8kIS/EEJ4IQl/IYTwQhL+Qgjhhf4/LxmYyYQFGIsAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -386,7 +418,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {
     "scrolled": true
    },
@@ -395,16 +427,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "energy: -1.4999670167944144\n",
-      "time: 26.714055061340332\n",
-      "maxcut objective: -3.9999670167944146\n",
-      "solution: [1. 0. 1. 0.]\n",
+      "energy: -1.4919238629420386\n",
+      "time: 11.324347019195557\n",
+      "maxcut objective: -3.9919238629420386\n",
+      "solution: [0. 1. 0. 1.]\n",
       "solution objective: 4.0\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -528,6 +560,56 @@
     "nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### [Optional] Checking that the full Hamiltonian made by ```docplex.get_qubitops```  gives the right cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "energy: -1.5\n",
+      "maxcut objective: -4.0\n",
+      "solution: [0. 1. 0. 1.]\n",
+      "solution objective: 4.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector\n",
+    "ee = ExactEigensolver(qubitOp_docplex, k=1)\n",
+    "result = ee.run()\n",
+    "\n",
+    "x = docplex.sample_most_likely(result['eigvecs'][0])\n",
+    "print('energy:', result['energy'])\n",
+    "print('maxcut objective:', result['energy'] + offset_docplex)\n",
+    "print('solution:', maxcut.get_graph_solution(x))\n",
+    "print('solution objective:', maxcut.maxcut_value(x, w))\n",
+    "\n",
+    "colors = ['r' if maxcut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]\n",
+    "nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -564,7 +646,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
@@ -572,14 +654,14 @@
      "output_type": "stream",
      "text": [
       "distance\n",
-      " [[ 0. 54. 74.]\n",
-      " [54.  0. 34.]\n",
-      " [74. 34.  0.]]\n"
+      " [[ 0. 61.  6.]\n",
+      " [61.  0. 57.]\n",
+      " [ 6. 57.  0.]]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -613,20 +695,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "order = (0, 1, 2) Distance = 162.0\n",
-      "Best order from brute force = (0, 1, 2) with total distance = 162.0\n"
+      "order = (0, 1, 2) Distance = 124.0\n",
+      "Best order from brute force = (0, 1, 2) with total distance = 124.0\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -681,7 +763,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -689,6 +771,44 @@
     "algo_input = EnergyInput(qubitOp)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### [Optional] Using DOcplex for mapping to the Ising problem\n",
+    "Using ```docplex.get_qubitops``` is a different way to create an Ising Hamiltonian of TSP. ```docplex.get_qubitops``` can create a corresponding Ising Hamiltonian from an optimization model of TSP. An example of using ```docplex.get_qubitops``` is as below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create an instance of a model and variables\n",
+    "mdl = Model(name='tsp')\n",
+    "x = {(i,p): mdl.binary_var(name='x_{0}_{1}'.format(i,p)) for i in range(n) for p in range(n)}\n",
+    "\n",
+    "# Object function\n",
+    "tsp_func = mdl.sum(ins.w[i,j] * x[(i,p)] * x[(j,(p+1)%n)] for i in range(n) for j in range(n) for p in range(n))\n",
+    "mdl.minimize(tsp_func)\n",
+    "\n",
+    "# Constrains\n",
+    "for i in range(n):\n",
+    "    mdl.add_constraint(mdl.sum(x[(i,p)] for p in range(n)) == 1)\n",
+    "for p in range(n):\n",
+    "    mdl.add_constraint(mdl.sum(x[(i,p)] for i in range(n)) == 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qubitOp_docplex, offset_docplex = docplex.get_qubitops(mdl)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -698,22 +818,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "energy: -600081.0\n",
+      "energy: -600062.0\n",
+      "tsp objective: 124.0\n",
       "feasible: True\n",
-      "solution: [1, 2, 0]\n",
-      "solution objective: 162.0\n"
+      "solution: [0, 1, 2]\n",
+      "solution objective: 124.0\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -741,7 +862,7 @@
     "result = run_algorithm(params,algo_input)\n",
     "\"\"\"\n",
     "print('energy:', result['energy'])\n",
-    "#print('tsp objective:', result['energy'] + offset)\n",
+    "print('tsp objective:', result['energy'] + offset)\n",
     "x = tsp.sample_most_likely(result['eigvecs'][0])\n",
     "print('feasible:', tsp.tsp_feasible(x))\n",
     "z = tsp.get_tsp_solution(x)\n",
@@ -849,6 +970,57 @@
     "draw_tsp_solution(G, z, colors, pos)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### [Optional] Checking that the full Hamiltonian made by ```docplex.get_qubitops```  gives the right cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "energy: -4532.0\n",
+      "tsp objective: 124.0\n",
+      "feasible: True\n",
+      "solution: [0, 1, 2]\n",
+      "solution objective: 124.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ee = ExactEigensolver(qubitOp_docplex, k=1)\n",
+    "result = ee.run()\n",
+    "\n",
+    "print('energy:', result['energy'])\n",
+    "print('tsp objective:', result['energy'] + offset_docplex)\n",
+    "\n",
+    "x = docplex.sample_most_likely(result['eigvecs'][0])\n",
+    "print('feasible:', tsp.tsp_feasible(x))\n",
+    "z = tsp.get_tsp_solution(x)\n",
+    "print('solution:', z)\n",
+    "print('solution objective:', tsp.tsp_value(z, ins.w))\n",
+    "draw_tsp_solution(G, z, colors, pos)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -874,7 +1046,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/qiskit/basics/the_ibmq_provider.ipynb b/qiskit/basics/the_ibmq_provider.ipynb
index 290223bf5..87a727fb0 100644
--- a/qiskit/basics/the_ibmq_provider.ipynb
+++ b/qiskit/basics/the_ibmq_provider.ipynb
@@ -543,7 +543,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "only return backends that are real devices, have more than 10 qubits and are operational"
+    "only return backends that are real devices, have at most 5 qubits and are operational"
    ]
   },
   {