{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Qubit Components" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import lightworks as lw\n", "from lightworks import emulator\n", "\n", "# Define backend to use for all simulations here\n", "backend = emulator.Backend(\"permanent\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using Qubit Gates\n", "All qubit components are in a dedicated 'qubit' sub-module of Lightworks. To access these, either the existing Lightworks import or a dedicated import of the qubit module can be used. As an example, to create a hadamard gate, either of the following would be valid." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "hadamard = lw.qubit.H()\n", "\n", "from lightworks import qubit # Could go at the top of the notebook\n", "\n", "hadamard = qubit.H()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Within this notebook we will use the latter for simplicity.\n", "\n", "All qubit components are designed to act on dual-rail encoded qubits, where a photon in the upper mode is the $\\ket{0}$ state and the $\\ket{1}$ mode is the lower state. This means for single qubit gates they act across two modes, dual qubit gates act across 4 modes etc... . It is assumed that the modes that the gate is acting on are adjacent to each other, so mode swaps may be required if this is not the case.\n", "\n", "Below, a circuit is created to support a single qubit, with each mode labelled, and the Hadamard gate is applied. This is then simulated to check the expected outputs, and it can be seen how this varies depending on whether the $\\ket{0}$ or $\\ket{1}$ state is input into the system." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "|0>\n", "|1>\n", "\n", "\n", "\n", "H\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
|1,0>|0,1>
|1,0>0.707107+0.000000j0.707107+0.000000j
|0,1>0.707107+0.000000j-0.707107+0.000000j
\n", "
" ], "text/plain": [ " |1,0> |0,1>\n", "|1,0> 0.707107+0.000000j 0.707107+0.000000j\n", "|0,1> 0.707107+0.000000j -0.707107+0.000000j" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit = lw.PhotonicCircuit(2) # Dual rail circuit\n", "\n", "circuit.add(hadamard, 0) # Add hadamard\n", "\n", "circuit.display(mode_labels=[\"|0>\", \"|1>\"])\n", "# |0> |1>\n", "sim = lw.Simulator(circuit, [lw.State([1, 0]), lw.State([0, 1])])\n", "results = backend.run(sim)\n", "\n", "results.display_as_dataframe()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Single Qubit Gates\n", "As mentioned, single qubit gates act across a pair of modes which encode a dual-rail encoded qubit. When adding these gates, it is important they are not used to mix modes which encode two different qubits as this creates an invalid result. \n", "\n", "The gates currently included in Lightworks are H, X, Y, Z, T and S, below these are applied across 3 different qubits, labelled A, B & C." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "A : |0>\n", "A : |1>\n", "B : |0>\n", "B : |1>\n", "C : |0>\n", "C : |1>\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "X\n", "\n", "\n", "\n", "\n", "\n", "Y\n", "\n", "\n", "\n", "\n", "\n", "Z\n", "\n", "\n", "\n", "\n", "\n", "S\n", "\n", "\n", "\n", "\n", "\n", "T\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "circuit = lw.PhotonicCircuit(6)\n", "\n", "# Qubit A\n", "circuit.add(qubit.H(), 0)\n", "circuit.add(qubit.X(), 0)\n", "\n", "# Qubit B\n", "circuit.add(qubit.Y(), 2)\n", "circuit.add(qubit.Z(), 2)\n", "\n", "# Qubit C\n", "circuit.add(qubit.S(), 4)\n", "circuit.add(qubit.T(), 4)\n", "\n", "circuit.display(\n", " mode_labels=[\n", " \"A : |0>\",\n", " \"A : |1>\",\n", " \"B : |0>\",\n", " \"B : |1>\",\n", " \"C : |0>\",\n", " \"C : |1>\",\n", " ]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Two Qubit Gates\n", "With two qubit gates, it is often more complicated as they typically require some sort of post-selection or heralding. Lightworks aims to make this easier by including integration of the heralding modes/photons within the circuit, meaning these can automatically be applied to simulation inputs and routed around when adding new components to the circuit. Depending on the component, however, some additional post-selection may still be required, information on this can be found in the documentation or the component docstring.\n", "\n", "To get started, below we create a 2 qubit CNOT gate. It can be seen how the heralds are shown on the upper and lower parts of the component, but not included within the main circuit modes. This particular gate requires post-selection on measuring 1 photon across the control qubit modes (0 & 1) and 1 photon across the target qubit modes (2 & 3)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "0\n", "1\n", "2\n", "3\n", "-\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cnot = lw.qubit.CNOT()\n", "\n", "cnot.display()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This CNOT gate can then be added to a circuit. In the following example, we'll aim to create the 3 qubit GHZ using a hadamard and 2 CNOTs. To start, we create the circuit, as it is a 3 qubit circuit it should have 6 modes. The H gate and CNOT are then added, it can be seen below how only the non-heralded modes of the CNOT are attached to the circuit modes." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "A : |0>\n", "A : |1>\n", "B : |0>\n", "B : |1>\n", "-\n", "C : |0>\n", "C : |1>\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "circ = lw.PhotonicCircuit(6)\n", "circ.add(lw.qubit.H(), 0)\n", "circ.add(cnot, 0)\n", "\n", "circ.display(\n", " mode_labels=[\n", " \"A : |0>\",\n", " \"A : |1>\",\n", " \"B : |0>\",\n", " \"B : |1>\",\n", " \"C : |0>\",\n", " \"C : |1>\",\n", " ]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A second CNOT is then integrated into the system, again this is automatically reconfigured to include the heralding requirements without these needing to be accounted for.\n", "\n", "One question you may have is if the CNOT above requires post-selection on the output, then why are we able to cascade the CNOTs without performing post-selection between each one. This works because we only interact the A and B qubits once, meaning at the output if we measure 1 photon across A0 & A1 then we can be sure that as long as the other photon is not lost and is not on the heralding modes then the gate worked correctly." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "A : |0>\n", "A : |1>\n", "-\n", "B : |0>\n", "B : |1>\n", "-\n", "C : |0>\n", "C : |1>\n", "-\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "circ.add(cnot, 2)\n", "\n", "circ.display(\n", " mode_labels=[\n", " \"A : |0>\",\n", " \"A : |1>\",\n", " \"B : |0>\",\n", " \"B : |1>\",\n", " \"C : |0>\",\n", " \"C : |1>\",\n", " ]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the system has been configured, it can be simulated through creation of a new Sampler object. The qubit_to_dual_rail method is used to automatically calculate the required dual-rail state." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "post_select = lw.PostSelection()\n", "post_select.add((0, 1), 1)\n", "post_select.add((2, 3), 1)\n", "post_select.add((4, 5), 1)\n", "\n", "sampler = lw.Sampler(\n", " circ,\n", " lw.convert.qubit_to_dual_rail(\"000\"),\n", " 10000,\n", " post_selection=post_select,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A number of samples are then measured from the system, and we apply a post-selection function to require only 1 photon is measured across each pair of photons corresponding to a qubit." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "results = backend.run(sampler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The results can then be viewed, as expected only the states $\\ket{1,0,1,0,1,0}$ and $\\ket{0,1,0,1,0,1}$ are measured, which correspond to the two expected measurements of the GHZ state, $\\ket{0,0,0}$ and $\\ket{1,1,1}$ respectively. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "results.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The qubit states can also be plotted directly by mapping the results." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "q_results = results.map(lw.convert.dual_rail_to_qubit)\n", "\n", "q_results.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Three Qubit Gates\n", "\n", "The Toffoli (CCNOT) & CCZ three qubit gates are also included within Lightworks. Similar to the two qubit gates above these require post-selection on measuring one photon across each of the qubit modes.\n", "\n", "In this tutorial we will look at the action of the CCNOT gate, which is created and displayed below." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "-\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "-\n", "-\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CCNOT ((0, 1), 2)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "\n", "0\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gate = lw.qubit.CCNOT()\n", "\n", "gate.display()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each of the possible valid input and outputs can then be simulated to view the action of the gate. After completion of the simulation, the data is extracted into an array in the order defined in all_inputs." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Define qubit inputs\n", "all_inputs = [\"000\", \"001\", \"100\", \"101\", \"010\", \"011\", \"110\", \"111\"]\n", "\n", "# Convert to mode values\n", "mapping = {\n", " input_: lw.State(lw.convert.qubit_to_dual_rail(input_))\n", " for input_ in all_inputs\n", "}\n", "\n", "# Simulate all combinations\n", "sim = lw.Simulator(gate, list(mapping.values()), list(mapping.values()))\n", "results = backend.run(sim)\n", "\n", "# Extract all results int array\n", "array = np.zeros((len(all_inputs), len(all_inputs)), dtype=complex)\n", "for i, si in enumerate(all_inputs):\n", " for j, sj in enumerate(all_inputs):\n", " array[i, j] = results[mapping[si], mapping[sj]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It can then be seen how a swap only takes place when both of the control qubits are in the 1 state." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb0AAAGwCAYAAAA9sLuaAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAKGVJREFUeJzt3X9wFPdh9/HPCUkHGO5k8UPna04VCaRA60oayYhjiC3HCoJgYoziQkupjAmMCZBiJXEi15YMY4YxmdgMQa7KTA1ux3YZJoTYbiIXy/xIJjI/hJVSh/CgifxIjjgBkaWzBEhC2ucPP+z4CjJCnLR3fN+vmf1j97u399nj5I/3bvfWZVmWJQAADJDgdAAAAIYLpQcAMAalBwAwBqUHADAGpQcAMAalBwAwBqUHADBGotMBYkFfX5+am5s1duxYuVwup+MAAG6SZVn65JNP5Pf7lZDQ//EcpSepublZgUDA6RgAgFvU1NSkL3zhC/2OU3qSxo4dK0n6vycy5BkTX5/4Pvzlu52OAACOu6Ie/Vq/sP973h9KT7I/0vSMSZBnbHyVXqIryekIAOC8//+Dmjf6iiq+/gsPAMAtoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMaIidKrqKhQRkaGRo4cqby8PB09etQeu3z5stasWaNx48ZpzJgxKioqUktLS8TjGxsbNX/+fI0ePVoTJ07U97//fV25cmW4dwMAEOMcL73du3erpKRE5eXlOnHihDIzM1VYWKhz585Jkp544gm9+eab2rNnjw4dOqTm5mYtWrTIfnxvb6/mz5+v7u5u/eY3v9Err7yiXbt2qayszKldAgDEKJdlWZaTAfLy8nTPPfdo+/btkqS+vj4FAgGtW7dOq1ev1oQJE/Taa6/pm9/8piTp97//vaZNm6aamhrNnDlTv/zlL/Xggw+qublZaWlpkqTKykr94Ac/0Pnz55WcnHzNc3Z1damrq8ueD4fDCgQC+vj/fFGesY7/f8BNKfRnOR0BABx3xerRQf1c7e3t8ng8/a7n6H/hu7u7VVtbq4KCAntZQkKCCgoKVFNTo9raWvX09ESMT506Venp6aqpqZEk1dTU6O6777YLT5IKCwsVDof1wQcfXPd5N2/eLK/Xa0+BQGCI9hAAEEscLb0LFy6ot7c3orAkKS0tTaFQSKFQSMnJyUpJSbnuuCSFQqHrPv7q2PWUlpaqvb3dnpqamqK0RwCAWJbodAAnuN1uud1up2MAAIaZo0d648eP14gRI645G7OlpUU+n08+n0/d3d1qa2u77rgk+Xy+6z7+6hgAAFc5WnrJycnKyclRdXW1vayvr0/V1dUKBoPKyclRUlJSxPjp06fV2NioYDAoSQoGgzp58qR9tqck7d+/Xx6PR9OnTx++nQEAxDzHP94sKSlRcXGxcnNzNWPGDG3dulWdnZ1avny5vF6vVqxYoZKSEqWmpsrj8WjdunUKBoOaOXOmJGnOnDmaPn26li1bpi1btigUCunpp5/WmjVr+AgTABDB8dJbvHixzp8/r7KyMoVCIWVlZamqqso+GeXFF19UQkKCioqK1NXVpcLCQr300kv240eMGKG33npLq1evVjAY1B133KHi4mJt3LjRqV0CAMQox6/TiwXhcFher5fr9AAgTsXFdXoAAAwnSg8AYAxKDwBgDEoPAGAMSg8AYAxKDwBgDEoPAGAMSg8AYAxKDwBgDEoPAGAMSg8AYAxKDwBgDEoPAGAMSg8AYAxKDwBgDMdvIhtLHv7y3Up0JTkd46a83VzndIRB4T6AAJzAkR4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBgxUXoVFRXKyMjQyJEjlZeXp6NHj9pjly9f1po1azRu3DiNGTNGRUVFamlpiXj8d77zHeXk5MjtdisrK2uY0wMA4oXjpbd7926VlJSovLxcJ06cUGZmpgoLC3Xu3DlJ0hNPPKE333xTe/bs0aFDh9Tc3KxFixZds53HHntMixcvHu74AIA44rIsy3IyQF5enu655x5t375dktTX16dAIKB169Zp9erVmjBhgl577TV985vflCT9/ve/17Rp01RTU6OZM2dGbOvZZ5/Vvn37VFdX97nP2dXVpa6uLns+HA4rEAgoXw8p0ZUU3R0cYm831zkdYVAK/VlORwBwG7li9eigfq729nZ5PJ5+13P0SK+7u1u1tbUqKCiwlyUkJKigoEA1NTWqra1VT09PxPjUqVOVnp6umpqaQT/v5s2b5fV67SkQCNzSfgAA4oOjpXfhwgX19vYqLS0tYnlaWppCoZBCoZCSk5OVkpJy3fHBKi0tVXt7uz01NTUNelsAgPiR6HQAJ7jdbrndbqdjAACGmaNHeuPHj9eIESOuORuzpaVFPp9PPp9P3d3damtru+44AAA3w9HSS05OVk5Ojqqrq+1lfX19qq6uVjAYVE5OjpKSkiLGT58+rcbGRgWDQSciAwDimOMfb5aUlKi4uFi5ubmaMWOGtm7dqs7OTi1fvlxer1crVqxQSUmJUlNT5fF4tG7dOgWDwYgzN+vr69XR0aFQKKRLly7ZZ29Onz5dycnJDu0ZACDWOF56ixcv1vnz51VWVqZQKKSsrCxVVVXZJ7e8+OKLSkhIUFFRkbq6ulRYWKiXXnopYhvf+ta3dOjQIXs+OztbktTQ0KCMjIxh2xcAQGxz/Dq9WBAOh+X1erlObxhxnR6AaIqL6/QAABhOlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGI7fRBa3Jl7vSxev9wGU4vc1B8CRHgDAIJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGI6W3uHDh7VgwQL5/X65XC7t27cvYtyyLJWVlemuu+7SqFGjVFBQoDNnzkSs09raqqVLl8rj8SglJUUrVqxQR0fHMO4FACBeOFp6nZ2dyszMVEVFxXXHt2zZom3btqmyslJHjhzRHXfcocLCQl2+fNleZ+nSpfrggw+0f/9+vfXWWzp8+LBWrVo1XLsAAIgjLsuyLKdDSJLL5dLPfvYzLVy4UNKnR3l+v1/f/e539b3vfU+S1N7errS0NO3atUtLlizRqVOnNH36dB07dky5ubmSpKqqKn3961/XRx99JL/fP6DnDofD8nq9ytdDSnQlDcn+IdLbzXVORxi0Qn+W0xEA/C9XrB4d1M/V3t4uj8fT73ox+51eQ0ODQqGQCgoK7GVer1d5eXmqqamRJNXU1CglJcUuPEkqKChQQkKCjhw50u+2u7q6FA6HIyYAwO0vZksvFApJktLS0iKWp6Wl2WOhUEgTJ06MGE9MTFRqaqq9zvVs3rxZXq/XngKBQJTTAwBiUcyW3lAqLS1Ve3u7PTU1NTkdCQAwDGK29Hw+nySppaUlYnlLS4s95vP5dO7cuYjxK1euqLW11V7netxutzweT8QEALj9xWzpTZo0ST6fT9XV1faycDisI0eOKBgMSpKCwaDa2tpUW1trr/Puu++qr69PeXl5w54ZABDbEp188o6ODtXX19vzDQ0NqqurU2pqqtLT07V+/Xo999xzmjJliiZNmqRnnnlGfr/fPsNz2rRpmjt3rlauXKnKykr19PRo7dq1WrJkyYDP3AQAmMPR0jt+/Ljuv/9+e76kpESSVFxcrF27dunJJ59UZ2enVq1apba2Ns2ePVtVVVUaOXKk/ZhXX31Va9eu1QMPPKCEhAQVFRVp27Ztw74vAIDYFzPX6TmJ6/SGH9fpAYimuL9ODwCAaKP0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxnD0zukwVzzfiDVeb4Abz685EC0c6QEAjEHpAQCMQekBAIxB6QEAjEHpAQCMQekBAIxB6QEAjEHpAQCMQekBAIxB6QEAjEHpAQCMQekBAIxB6QEAjEHpAQCMQekBAIxB6QEAjEHpAQCMQekBAIzhaOkdPnxYCxYskN/vl8vl0r59+yLGLctSWVmZ7rrrLo0aNUoFBQU6c+ZMxDqbNm3SrFmzNHr0aKWkpAxfeABA3HG09Do7O5WZmamKiorrjm/ZskXbtm1TZWWljhw5ojvuuEOFhYW6fPmyvU53d7ceeeQRrV69erhiAwDiVKKTTz5v3jzNmzfvumOWZWnr1q16+umn9dBDD0mS/u3f/k1paWnat2+flixZIknasGGDJGnXrl3DkhkAEL9i9ju9hoYGhUIhFRQU2Mu8Xq/y8vJUU1NzS9vu6upSOByOmAAAt7+YLb1QKCRJSktLi1ielpZmjw3W5s2b5fV67SkQCNzS9gAA8SFmS28olZaWqr293Z6ampqcjgQAGAYxW3o+n0+S1NLSErG8paXFHhsst9stj8cTMQEAbn8xW3qTJk2Sz+dTdXW1vSwcDuvIkSMKBoMOJgMAxCtHz97s6OhQfX29Pd/Q0KC6ujqlpqYqPT1d69ev13PPPacpU6Zo0qRJeuaZZ+T3+7Vw4UL7MY2NjWptbVVjY6N6e3tVV1cnSZo8ebLGjBkzzHsEAIhljpbe8ePHdf/999vzJSUlkqTi4mLt2rVLTz75pDo7O7Vq1Sq1tbVp9uzZqqqq0siRI+3HlJWV6ZVXXrHns7OzJUkHDhxQfn7+8OwIACAuuCzLspwO4bRwOCyv16t8PaREV5LTcRDj3m6uczrCoBT6s5yOAAyZK1aPDurnam9v/9zzNGL2Oz0AAKKN0gMAGGNQpbdx40ZdvHjxmuWXLl3Sxo0bbzkUAABDYVClt2HDBnV0dFyz/OLFi/ZvYQIAEGsGVXqWZcnlcl2z/Le//a1SU1NvORQAAEPhpi5ZuPPOO+VyueRyufTlL385ovh6e3vV0dGhxx9/POohAQCIhpsqva1bt8qyLD322GPasGGDvF6vPZacnKyMjAx+LQUAELNuqvSKi4slffoTYbNmzVJSEte0AQDix6B+kWXSpEk6e/Zsv+Pp6emDDgQAwFAZVOllZGRc90SWq3p7ewcdCACAoTKo0nv//fcj5nt6evT+++/rhRde0KZNm6ISDACAaBtU6WVmZl6zLDc3V36/Xz/60Y+0aNGiWw4GAEC0RfVnyP7iL/5Cx44di+YmAQCImkEd6YXD4Yh5y7J09uxZPfvss5oyZUpUggEAEG2DKr2UlJRrTmSxLEuBQED/8R//EZVgAABE26BK78CBAxHzCQkJmjBhgiZPnqzEREfvSwsAQL8G1VD33XdftHMAcSNeb8bKzW+BQZaeJJ0+fVo/+clPdOrUKUnStGnTtHbtWk2dOjVq4QAAiKZBnb3505/+VH/1V3+l2tpaZWZmKjMzUydOnNDdd9+tn/70p9HOCABAVAzqSO/JJ59UaWnpNTeMLS8v15NPPqmioqKohAMAIJoGdaR39uxZ/cM//MM1y//+7//+c3+TEwAAJw2q9PLz8/WrX/3qmuW//vWv9ZWvfOWWQwEAMBQG9fHmN77xDf3gBz9QbW2tZs6cKUl67733tGfPHm3YsEFvvPFGxLoAAMQCl2VZ1s0+KCFhYAeILpcrLu64EA6H5fV6la+HlOjiHoG4PXHJAm5nV6weHdTP1d7eLo/H0+96gzrS6+vrG3QwAACcEtUfnAYAIJYN+uL06upqVVdX69y5c9cc+b388su3HAwAgGgbVOlt2LBBGzduVG5uru66667PvYs6AACxYlClV1lZqV27dmnZsmXRzgMAwJAZ1Hd63d3dmjVrVrSzAAAwpAZVet/61rf02muvRTsLAABDalAfb16+fFk7duzQO++8o7/+679WUlLktW0vvPBCVMIBABBNgyq9//7v/1ZWVpYk6X/+53+imQcAgCETlTunAwAQD26q9BYtWnTDdVwuF/fUAwDEpJs6kcXr9d5w+rzfPOtPRUWFMjIyNHLkSOXl5eno0aP22I4dO5Sfny+PxyOXy6W2trZrHt/a2qqlS5fK4/EoJSVFK1asUEdHx03nAADc3m7qSG/nzp1RD7B7926VlJSosrJSeXl52rp1qwoLC3X69GlNnDhRFy9e1Ny5czV37lyVlpZedxtLly7V2bNntX//fvX09Gj58uVatWoVZ5gCACIM6i4L0ZSXl6d77rlH27dvl/Tpj1kHAgGtW7dOP/zhD+31Dh48qPvvv18ff/yxUlJS7OWnTp3S9OnTdezYMeXm5kqSqqqq9PWvf10fffSR/H7/DTNwlwWYgLss4HY20LssOPqD093d3aqtrVVBQYG9LCEhQQUFBaqpqRnQNmpqapSSkmIXniQVFBQoISFBR44cue5jurq6FA6HIyYAwO3P0dK7cOGCent7lZaWFrE8LS1NoVBoQNsIhUKaOHFixLLExESlpqb2u43NmzdHfA8ZCAQGtwMAgLhi5K2FSktL1d7ebk9NTU1ORwIADINB31ooGsaPH68RI0aopaUlYnlLS4t8Pt+AtuHz+XTu3LmIZVeuXFFra2u/23C73XK73YMLDQCIW44e6SUnJysnJ0fV1dX2sr6+PlVXVysYDA5oG8FgUG1tbaqtrbWXvfvuu+rr61NeXl7UMwMA4pejR3qSVFJSouLiYuXm5mrGjBnaunWrOjs7tXz5ckmffmcXCoVUX18vSTp58qTGjh2r9PR0paamatq0aZo7d65WrlypyspK9fT0aO3atVqyZMmAztwEAJjD8dJbvHixzp8/r7KyMoVCIWVlZamqqso+uaWyslIbNmyw17/33nslfXrN4KOPPipJevXVV7V27Vo98MADSkhIUFFRkbZt2zbs+wIAiG2OX6cXC7hODybgOj3czuLiOj0AAIYTpQcAMAalBwAwBqUHADAGpQcAMAalBwAwBqUHADAGpQcAMAalBwAwBqUHADAGpQcAMAalBwAwBqUHADAGpQcAMAalBwAwBqUHADCG43dOBzA84vVmrNz8FtHEkR4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBgxUXoVFRXKyMjQyJEjlZeXp6NHj9pjO3bsUH5+vjwej1wul9ra2q55/KZNmzRr1iyNHj1aKSkpwxccABBXHC+93bt3q6SkROXl5Tpx4oQyMzNVWFioc+fOSZIuXryouXPn6qmnnup3G93d3XrkkUe0evXq4YoNAIhDiU4HeOGFF7Ry5UotX75cklRZWan//M//1Msvv6wf/vCHWr9+vSTp4MGD/W5jw4YNkqRdu3YN6Dm7urrU1dVlz4fD4UFlBwDEF0eP9Lq7u1VbW6uCggJ7WUJCggoKClRTUzNkz7t582Z5vV57CgQCQ/ZcAIDY4WjpXbhwQb29vUpLS4tYnpaWplAoNGTPW1paqvb2dntqamoasucCAMQOxz/edILb7Zbb7XY6BgBgmDl6pDd+/HiNGDFCLS0tEctbWlrk8/kcSgUAuF05WnrJycnKyclRdXW1vayvr0/V1dUKBoMOJgMA3I4c/3izpKRExcXFys3N1YwZM7R161Z1dnbaZ3OGQiGFQiHV19dLkk6ePKmxY8cqPT1dqampkqTGxka1traqsbFRvb29qqurkyRNnjxZY8aMcWS/AACxx/HSW7x4sc6fP6+ysjKFQiFlZWWpqqrKPrmlsrLSviRBku69915J0s6dO/Xoo49KksrKyvTKK6/Y62RnZ0uSDhw4oPz8/OHZEQBAzHNZlmU5HcJp4XBYXq9X+XpIia4kp+MA+Iy3m+ucjjAohf4spyMY5YrVo4P6udrb2+XxePpdz/FfZAEAYLhQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjOH4TWQD4PNyXbvjF4z0Mw5/06c4v33g9jvQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMag9AAAxqD0AADGoPQAAMZwtPQOHz6sBQsWyO/3y+Vyad++fRHje/fu1Zw5czRu3Di5XC7V1dVds43Lly9rzZo1GjdunMaMGaOioiK1tLQMzw4AAOKKo6XX2dmpzMxMVVRU9Ds+e/ZsPf/88/1u44knntCbb76pPXv26NChQ2pubtaiRYuGKjIAII4lOvnk8+bN07x58/odX7ZsmSTpww8/vO54e3u7/vVf/1WvvfaavvrVr0qSdu7cqWnTpum9997TzJkzr/u4rq4udXV12fPhcHiQewAAiCdx/Z1ebW2tenp6VFBQYC+bOnWq0tPTVVNT0+/jNm/eLK/Xa0+BQGA44gIAHBbXpRcKhZScnKyUlJSI5WlpaQqFQv0+rrS0VO3t7fbU1NQ0xEkBALHA0Y83neJ2u+V2u52OAQAYZnF9pOfz+dTd3a22traI5S0tLfL5fM6EAgDErLguvZycHCUlJam6utpedvr0aTU2NioYDDqYDAAQixz9eLOjo0P19fX2fENDg+rq6pSamqr09HS1traqsbFRzc3Nkj4tNOnTIzyfzyev16sVK1aopKREqamp8ng8WrdunYLBYL9nbgIAzOXokd7x48eVnZ2t7OxsSVJJSYmys7NVVlYmSXrjjTeUnZ2t+fPnS5KWLFmi7OxsVVZW2tt48cUX9eCDD6qoqEj33nuvfD6f9u7dO/w7AwCIeS7LsiynQzgtHA7L6/UqXw8p0ZXkdBwAcNTbzXVOR7hp4U/6dOeX/6D29nZ5PJ5+14vr7/QAALgZlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYlB4AwBiUHgDAGJQeAMAYiU4HAIDbUTzeiPWqQn+W0xFu2hWrR9IfbrgeR3oAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjOFp6hw8f1oIFC+T3++VyubRv376I8b1792rOnDkaN26cXC6X6urqrtnGjh07lJ+fL4/HI5fLpba2tmHJDgCIP46WXmdnpzIzM1VRUdHv+OzZs/X888/3u42LFy9q7ty5euqpp4YqJgDgNpHo5JPPmzdP8+bN63d82bJlkqQPP/yw33XWr18vSTp48GAUkwEAbkeOlp5Turq61NXVZc+Hw2EH0wAAhouRJ7Js3rxZXq/XngKBgNORAADDwMjSKy0tVXt7uz01NTU5HQkAMAyM/HjT7XbL7XY7HQMAMMyMPNIDAJjJ0SO9jo4O1dfX2/MNDQ2qq6tTamqq0tPT1draqsbGRjU3N0uSTp8+LUny+Xzy+XySpFAopFAoZG/n5MmTGjt2rNLT05WamjrMewQAiGWOHukdP35c2dnZys7OliSVlJQoOztbZWVlkqQ33nhD2dnZmj9/viRpyZIlys7OVmVlpb2NyspKZWdna+XKlZKke++9V9nZ2XrjjTeGeW8AALHOZVmW5XQIp4XDYXm9XuXrISW6kpyOA+A28HZzndMRBq3Qn+V0hJt2xerRQf1c7e3t8ng8/a7Hd3oAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABjOHrn9Fhx9ZaCV9QjGX93QQDREP6kz+kIg3bF6nE6wk27ok8z3+gWsdxEVtJHH32kQCDgdAwAwC1qamrSF77whX7HKT1JfX19am5u1tixY+VyuaK67XA4rEAgoKamps+9m2+sIffwi9fs5B5e5L4+y7L0ySefyO/3KyGh/2/u+HhTUkJCwuf+n0E0eDyeuHqDXkXu4Rev2ck9vMh9La/Xe8N1OJEFAGAMSg8AYAxKb4i53W6Vl5fL7XY7HeWmkHv4xWt2cg8vct8aTmQBABiDIz0AgDEoPQCAMSg9AIAxKD0AgDEovVtQUVGhjIwMjRw5Unl5eTp69Kg9dvnyZa1Zs0bjxo3TmDFjVFRUpJaWlojHNzY2av78+Ro9erQmTpyo73//+7py5UrM5/7Od76jnJwcud1uZWVlDXleSTp8+LAWLFggv98vl8ulffv2RYxblqWysjLdddddGjVqlAoKCnTmzJmIdVpbW7V06VJ5PB6lpKRoxYoV6ujoiPncmzZt0qxZszR69GilpKQMad7P+rz3yY4dO5Sfny+PxyOXy6W2trZrHu/E6x2t7E685jd6r+zdu1dz5szRuHHj5HK5VFdXd802BvL3G4u5B/JvEi2U3iDt3r1bJSUlKi8v14kTJ5SZmanCwkKdO3dOkvTEE0/ozTff1J49e3To0CE1Nzdr0aJF9uN7e3s1f/58dXd36ze/+Y1eeeUV7dq1S2VlZTGd+6rHHntMixcvHtKsn9XZ2anMzExVVFRcd3zLli3atm2bKisrdeTIEd1xxx0qLCzU5cuX7XWWLl2qDz74QPv379dbb72lw4cPa9WqVTGfu7u7W4888ohWr149pFk/60bvk4sXL2ru3Ll66qmn+t2GE693tLI78Zrf6L3S2dmp2bNn6/nnn+93GwP9+42maOQeyL9J1FgYlBkzZlhr1qyx53t7ey2/329t3rzZamtrs5KSkqw9e/bY46dOnbIkWTU1NZZlWdYvfvELKyEhwQqFQvY6//zP/2x5PB6rq6srZnN/Vnl5uZWZmTlkWfsjyfrZz35mz/f19Vk+n8/60Y9+ZC9ra2uz3G639frrr1uWZVm/+93vLEnWsWPH7HV++ctfWi6Xy/rjH/8Ys7k/a+fOnZbX6x2GpJ//PvmsAwcOWJKsjz/+OGK5k6/3rWb/rOF8zT/rf79XPquhocGSZL3//vsRy2/273coDCb3Zw3k3+RWcaQ3CN3d3aqtrVVBQYG9LCEhQQUFBaqpqVFtba16enoixqdOnar09HTV1NRIkmpqanT33XcrLS3NXqewsFDhcFgffPBBzOaORQ0NDQqFQhG5vV6v8vLyIl7vlJQU5ebm2usUFBQoISFBR44cGfbM0sByO+FG75OBcOr1jkb2eBWvf7/DjdIbhAsXLqi3tzeisCQpLS1NoVBIoVBIycnJ13wXcHVckkKh0HUff3UsVnPHoqvZ+tuvq+tMnDgxYjwxMVGpqamO7dtAcjvhRu+TgXDq9Y5G9ngVr3+/w43SAwAYg9IbhPHjx2vEiBHXnBXV0tIin88nn8+n7u7ua85AujouST6f77qPvzoWq7lj0dVs/e3X1XWunshw1ZUrV9Ta2urYvg0ktxNu9D4ZCKde72hkj1fx+vc73Ci9QUhOTlZOTo6qq6vtZX19faqurlYwGFROTo6SkpIixk+fPq3GxkYFg0FJUjAY1MmTJyP+w7B//355PB5Nnz49ZnPHokmTJsnn80XkDofDOnLkSMTr3dbWptraWnudd999V319fcrLyxv2zNLAcjvhRu+TgXDq9Y5G9ngVr3+/w42byA5SSUmJiouLlZubqxkzZmjr1q3q7OzU8uXL5fV6tWLFCpWUlCg1NVUej0fr1q1TMBjUzJkzJUlz5szR9OnTtWzZMm3ZskWhUEhPP/201qxZM6S/Qn6ruSWpvr5eHR0dCoVCunTpkn3dzfTp05WcnDwkuTs6OlRfX2/PNzQ0qK6uTqmpqUpPT9f69ev13HPPacqUKZo0aZKeeeYZ+f1+LVy4UJI0bdo0zZ07VytXrlRlZaV6enq0du1aLVmyRH6/f0gyRyO39On1nK2trWpsbFRvb6/9ek+ePFljxowZktyf9z6RZH8HfHXfTp48qbFjxyo9PV2pqamOvd7RyC4585rf6L1yNU9zc7OkTwtNkv0pzUD/fmMttzSwf5OoGbLzQg3wk5/8xEpPT7eSk5OtGTNmWO+99549dunSJevb3/62deedd1qjR4+2Hn74Yevs2bMRj//www+tefPmWaNGjbLGjx9vffe737V6enpiPvd9991nSbpmamhoGLLMV09l/t9TcXGxZVmfnv7/zDPPWGlpaZbb7bYeeOAB6/Tp0xHb+NOf/mT97d/+rTVmzBjL4/FYy5cvtz755JMhyxyt3MXFxdfdxoEDB4Y0++e9T8rLy6+baefOnfY6Trze0cruxGt+o/fKzp07rzteXl5ub2Mgf7+xmHsg/ybRwq2FAADG4Ds9AIAxKD0AgDEoPQCAMSg9AIAxKD0AgDEoPQCAMSg9AIAxKD0AgDEoPQCAMSg9IMY0NTXpsccek9/vV3Jysv78z/9c//iP/6g//elPA97Ghx9+KJfLZf9mZLS5XC7t27dvSLYNDCVKD4ghf/jDH5Sbm6szZ87o9ddfV319vSorK+27BLS2tjodEYhrlB4QQ9asWaPk5GT913/9l+677z6lp6dr3rx5euedd/THP/5R//RP/yTp+kdaKSkp2rVrl6RPb1skSdnZ2XK5XMrPz5ckPfroo1q4cKE2bNigCRMmyOPx6PHHH1d3d7e9nYyMDG3dujVi21lZWXr22WftcUl6+OGH5XK57HkgHlB6QIxobW3V22+/rW9/+9saNWpUxJjP59PSpUu1e/duDeQ34o8ePSpJeuedd3T27Fnt3bvXHquurtapU6d08OBBvf7669q7d682bNgw4JzHjh2TJO3cuVNnz56154F4QOkBMeLMmTOyLEvTpk277vi0adP08ccf6/z58zfc1oQJEyRJ48aNk8/ni7gnWXJysl5++WX95V/+pebPn6+NGzdq27Zt6uvrG1DOq9tOSUmRz+ez54F4QOkBMWao7/aVmZmp0aNH2/PBYFAdHR1qamoa0ucFYgGlB8SIyZMny+Vy6dSpU9cdP3XqlO68805NmDBBLpfrmnLs6emJSo6EhIQh2zbgNEoPiBHjxo3T1772Nb300ku6dOlSxFgoFNKrr76qxYsXy+VyacKECTp79qw9fubMGV28eNGeT05OliT19vZe8zy//e1vI7b/3nvvacyYMQoEApJ0zbbD4bAaGhoitpGUlHTdbQOxjtIDYsj27dvV1dWlwsJCHT58WE1NTaqqqtLXvvY1/dmf/Zk2bdokSfrqV7+q7du36/3339fx48f1+OOPKykpyd7OxIkTNWrUKFVVVamlpUXt7e32WHd3t1asWKHf/e53+sUvfqHy8nKtXbtWCQkJ9rb//d//Xb/61a908uRJFRcXa8SIERE5MzIyVF1drVAopI8//ngYXhkgOig9IIZMmTJFx48f1xe/+EX9zd/8jb70pS9p1apVuv/++1VTU2OfkPLjH/9YgUBAX/nKV/R3f/d3+t73vhfxPV1iYqK2bdumf/mXf5Hf79dDDz1kjz3wwAOaMmWK7r33Xi1evFjf+MY37MsRJKm0tFT33XefHnzwQc2fP18LFy7Ul770pYicP/7xj7V//34FAgFlZ2cP7YsCRJHLGupvzQHEjEcffVRtbW38mgqMxZEeAMAYlB4AwBh8vAkAMAZHegAAY1B6AABjUHoAAGNQegAAY1B6AABjUHoAAGNQegAAY1B6AABj/D8sJmT0E8QwqQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.imshow(abs(array) ** 2)\n", "plt.xticks(range(len(all_inputs)), all_inputs)\n", "plt.yticks(range(len(all_inputs)), all_inputs)\n", "plt.ylabel(\"Input\")\n", "plt.xlabel(\"Output\")\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "venv", "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.11.6" } }, "nbformat": 4, "nbformat_minor": 2 }