basis_change.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.quantum_info import random_statevector\n",
    "import create_statevector as cs\n",
    "import entanglement_class as entang"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = entang.Entangled(4)\n",
    "\n",
    "amplitudes = [0, 2, 3, 5, 0, 7, 8, 9, 0, 11, 0, 13, 17, 19, 0, 1]\n",
    "x = test.init_statevector()\n",
    "\n",
    "for index in range(len(amplitudes)):\n",
    "    x[list(x.keys())[index]] = amplitudes[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0000': 0,\n",
       " '0001': 2,\n",
       " '0010': 3,\n",
       " '0011': 5,\n",
       " '0100': 0,\n",
       " '0101': 7,\n",
       " '0110': 8,\n",
       " '0111': 9,\n",
       " '1000': 0,\n",
       " '1001': 11,\n",
       " '1010': 0,\n",
       " '1011': 13,\n",
       " '1100': 17,\n",
       " '1101': 19,\n",
       " '1110': 0,\n",
       " '1111': 1}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0, '0001': 2, '0010': 3, '0011': 5, '0100': 0, '0101': 7, '0110': 8, '0111': 9, '1000': 0, '1001': 11, '1010': 0, '1011': 13, '1100': 17, '1101': 19, '1110': 0, '1111': 1}\n",
      "{'1011': 0, '1010': 2, '1001': 3, '1000': 5, '1111': 0, '1110': 7, '1101': 8, '1100': 9, '0011': 0, '0010': 11, '0001': 0, '0000': 13, '0111': 17, '0110': 19, '0101': 0, '0100': 1}\n"
     ]
    }
   ],
   "source": [
    "# basis change method 1\n",
    "new_x = test.basis_change_method_one(x, '1011')\n",
    "\n",
    "print(x)\n",
    "print(new_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0, '0001': 2, '0010': 3, '0011': 5, '0100': 0, '0101': 7, '0110': 8, '0111': 9, '1000': 0, '1001': 11, '1010': 0, '1011': 13, '1100': 17, '1101': 19, '1110': 0, '1111': 1}\n",
      "{'0000': 13, '0001': 0, '0010': 11, '0011': 0, '0100': 1, '0101': 0, '0110': 19, '0111': 17, '1000': 5, '1001': 3, '1010': 2, '1011': 0, '1100': 9, '1101': 8, '1110': 7, '1111': 0}\n"
     ]
    }
   ],
   "source": [
    "# basis change method 2\n",
    "new_x_two = test.basis_change_method_two(x, '1011')\n",
    "\n",
    "print(x)\n",
    "print(new_x_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Psi> is Entangled\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'0011': {'basis_kets': ['0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '0101': {'basis_kets': ['0100', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '0110': {'basis_kets': ['0100', '0010'],\n",
       "  'target_amplitude': 0.0650887573964497,\n",
       "  'equality': False},\n",
       " '0111': {'basis_kets': ['0100', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1001': {'basis_kets': ['1000', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1010': {'basis_kets': ['1000', '0010'],\n",
       "  'target_amplitude': 0.3254437869822485,\n",
       "  'equality': False},\n",
       " '1011': {'basis_kets': ['1000', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '1100': {'basis_kets': ['1000', '0100'],\n",
       "  'target_amplitude': 0.02958579881656805,\n",
       "  'equality': False},\n",
       " '1101': {'basis_kets': ['1000', '0100', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1110': {'basis_kets': ['1000', '0100', '0010'],\n",
       "  'target_amplitude': 0.025034137460172964,\n",
       "  'equality': False},\n",
       " '1111': {'basis_kets': ['1000', '0100', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True}}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.entangled(new_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Psi> is Entangled\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'0011': {'basis_kets': ['0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '0101': {'basis_kets': ['0100', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '0110': {'basis_kets': ['0100', '0010'],\n",
       "  'target_amplitude': 0.0650887573964497,\n",
       "  'equality': False},\n",
       " '0111': {'basis_kets': ['0100', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1001': {'basis_kets': ['1000', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1010': {'basis_kets': ['1000', '0010'],\n",
       "  'target_amplitude': 0.3254437869822485,\n",
       "  'equality': False},\n",
       " '1011': {'basis_kets': ['1000', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True},\n",
       " '1100': {'basis_kets': ['1000', '0100'],\n",
       "  'target_amplitude': 0.02958579881656805,\n",
       "  'equality': False},\n",
       " '1101': {'basis_kets': ['1000', '0100', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': False},\n",
       " '1110': {'basis_kets': ['1000', '0100', '0010'],\n",
       "  'target_amplitude': 0.025034137460172964,\n",
       "  'equality': False},\n",
       " '1111': {'basis_kets': ['1000', '0100', '0010', '0001'],\n",
       "  'target_amplitude': 0.0,\n",
       "  'equality': True}}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.entangled(new_x_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mentangled\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/Documents/code/entanglement/qiskit/entanglement_criteria/entanglement_class.py:412\u001b[0m, in \u001b[0;36mEntangled.entangled\u001b[0;34m(self, statevector)\u001b[0m\n\u001b[1;32m    410\u001b[0m \u001b[38;5;66;03m# check zero ket amplitude and normalize if not equal to 1        \u001b[39;00m\n\u001b[1;32m    411\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m statevector[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m0\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnumber_qubits] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 412\u001b[0m     statevector \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_statevector\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatevector\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    414\u001b[0m \u001b[38;5;66;03m# initalize set of booleans\u001b[39;00m\n\u001b[1;32m    415\u001b[0m booleans \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/Documents/code/entanglement/qiskit/entanglement_criteria/entanglement_class.py:576\u001b[0m, in \u001b[0;36mEntangled.normalize_statevector\u001b[0;34m(self, statevector)\u001b[0m\n\u001b[1;32m    573\u001b[0m zero_ket_amplitude \u001b[38;5;241m=\u001b[39m statevector[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m0\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnumber_qubits]\n\u001b[1;32m    575\u001b[0m \u001b[38;5;66;03m# divide all amplitudes by zero ket amplitude\u001b[39;00m\n\u001b[0;32m--> 576\u001b[0m normalized_statevector \u001b[38;5;241m=\u001b[39m \u001b[43m{\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m    577\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mzero_ket_amplitude\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstatevector\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    578\u001b[0m \u001b[43m    \u001b[49m\u001b[43m}\u001b[49m\n\u001b[1;32m    580\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m normalized_statevector\n",
      "File \u001b[0;32m~/Documents/code/entanglement/qiskit/entanglement_criteria/entanglement_class.py:577\u001b[0m, in \u001b[0;36m<dictcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    573\u001b[0m zero_ket_amplitude \u001b[38;5;241m=\u001b[39m statevector[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m0\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnumber_qubits]\n\u001b[1;32m    575\u001b[0m \u001b[38;5;66;03m# divide all amplitudes by zero ket amplitude\u001b[39;00m\n\u001b[1;32m    576\u001b[0m normalized_statevector \u001b[38;5;241m=\u001b[39m { \n\u001b[0;32m--> 577\u001b[0m     key: \u001b[43mvalue\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mzero_ket_amplitude\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m statevector\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m    578\u001b[0m     }\n\u001b[1;32m    580\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m normalized_statevector\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "test.entangled(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0101\n"
     ]
    }
   ],
   "source": [
    "ket = '1010'\n",
    "\n",
    "# Python strings are immutable, so create new string\n",
    "# or convert to binary integer and use XOR\n",
    "# then convert back to string\n",
    "\n",
    "# this flips all bits of a bitstring\n",
    "def flip_bits(ket):\n",
    "    new_ket = \"\"\n",
    "    for bit in ket:\n",
    "        if bit == '0':\n",
    "            new_ket += '1'\n",
    "        else:\n",
    "            new_ket += '0'\n",
    "    return new_ket\n",
    "\n",
    "flipped_ket = flip_bits(ket)\n",
    "\n",
    "print(flipped_ket)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 3]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basis Change Method 1: work with text strings\n",
    "\n",
    "# Can skip this index process entirely\n",
    "# and use bitwise XOR with binary ints\n",
    "# this method can be used to build ket in new basis\n",
    "def get_bit_flip_indices(ket):\n",
    "    return [index for index, bit in enumerate(ket) if bit == \"1\"]\n",
    "\n",
    "bit_flip_indices = get_bit_flip_indices('1011')\n",
    "\n",
    "bit_flip_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 3]\n",
      "0001\n"
     ]
    }
   ],
   "source": [
    "def flip_certain_bits(ket, list):\n",
    "    new_ket = \"\"\n",
    "    for index in range(len(ket)):\n",
    "        if index not in list:\n",
    "            new_ket += ket[index]\n",
    "        elif ket[index] == '0':\n",
    "            new_ket += '1'\n",
    "        else:\n",
    "            new_ket += '0'\n",
    "    return new_ket\n",
    "\n",
    "test = flip_certain_bits(ket, bit_flip_indices)\n",
    "\n",
    "print(bit_flip_indices)\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number formatted in binary\n",
    "0b10**4\n",
    "\n",
    "# binary strings\n",
    "bin(0b10**4)\n",
    "bin(5)\n",
    "\n",
    "# format result as string of length 4\n",
    "format(0b1010 ^ 0b1011, '0'+'4'+'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0001'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basis Change Method 2: work with XOR operation on binary numbers\n",
    "# convert ket strings to int base 2\n",
    "# perform XOR\n",
    "# format as string of length = number_qubits\n",
    "test = (int('1010',2))^(int('1011',2))\n",
    "format(test, '0'+'4'+'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# old notes:\n",
    "# Change of basis when zero ket amplitude is equal to 0\n",
    "# involves choosing a ket and flipping all bits equal to '1'\n",
    "# store index of each bit that is flipped\n",
    "# flip bits at those same indices in all other kets (statevector.keys())\n",
    "# make a copy of statevector first so that user statevector is not altered\n",
    "# note that we don't necessarily need the new statevector keys to be in \n",
    "# ascending order since amplitudes are accessed by kets, not indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notes\n",
    "# list comprehension if/else:\n",
    "# https://stackoverflow.com/questions/4260280/if-else-in-a-list-comprehension\n",
    "            \n",
    "# if/else: [f(x) if condition else g(x) for x in sequence]\n",
    "# if only: [f(x) for x in sequence if condition]\n",
    "\n",
    "# [powers[index] for index, bit in enumerate(ket) if bit == \"1\"]\n",
    "\n",
    "# L = [ket[index] = 1 if ket[index] == 0 else ket[index] = 0 for index in list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notes\n",
    "\n",
    "\"\"\"\n",
    "new dictionary from list comprehension:\n",
    "    dict = {\n",
    "        (key): (value) for (item) in (list) \n",
    "        }\n",
    "\"\"\"\n",
    "\"\"\"\n",
    "new dictionary from dictionary comprehension:\n",
    "    dict = { \n",
    "        (key): (value) for (key, value) in dictionary.items()\n",
    "        }\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0, '0001': 2, '0010': 3, '0011': 5, '0100': 0, '0101': 7, '0110': 8, '0111': 9, '1000': 0, '1001': 11, '1010': 0, '1011': 13, '1100': 17, '1101': 19, '1110': 0, '1111': 1}\n",
      "{'1011': 0, '1010': 2, '1001': 3, '1000': 5, '1111': 0, '1110': 7, '1101': 8, '1100': 9, '0011': 0, '0010': 11, '0001': 0, '0000': 13, '0111': 17, '0110': 19, '0101': 0, '0100': 1}\n"
     ]
    }
   ],
   "source": [
    "# perform basis change for all kets in a statevector\n",
    "# use dictionary comprehension over statevector\n",
    "# this will 'shuffle' kets around, though that shouldn't make a difference \n",
    "# in entangled() method since kets are only used reference amplitudes and \n",
    "# place in decomp_dictionary, which is ordered   \n",
    "\n",
    "# perform basis change on a single ket (using Method 2)\n",
    "def basis_change_ket(target_ket, source_ket):\n",
    "    target_ket = format(\n",
    "        (int(target_ket,2))^(int(source_ket,2)), '0'+str(len(source_ket))+'b'\n",
    "        )\n",
    "    return target_ket\n",
    "\n",
    "# perform basis change on kets and generate a new statevector\n",
    "# note:  can this be done with Python map() method?\n",
    "def basis_change(statevector, source_ket):\n",
    "    new_statevector = {\n",
    "        basis_change_ket(key, source_ket): value\n",
    "        # format((int(key,2))^(int(ket,2)), '0'+str(len(ket))+'b'): value \n",
    "        for (key, value) in statevector.items()\n",
    "    }\n",
    "\n",
    "    return new_statevector\n",
    "\n",
    "new_statevector = basis_change(x, '1011')\n",
    "\n",
    "print(x)\n",
    "print(new_statevector)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0, '0001': 2, '0010': 3, '0011': 5, '0100': 0, '0101': 7, '0110': 8, '0111': 9, '1000': 0, '1001': 11, '1010': 0, '1011': 13, '1100': 17, '1101': 19, '1110': 0, '1111': 1}\n",
      "{'0000': '1011', '0001': '1010', '0010': '1001', '0011': '1000', '0100': '1111', '0101': '1110', '0110': '1101', '0111': '1100', '1000': '0011', '1001': '0010', '1010': '0001', '1011': '0000', '1100': '0111', '1101': '0110', '1110': '0101', '1111': '0100'}\n"
     ]
    }
   ],
   "source": [
    "    \n",
    "# instead of copy and edit statevector keys directly, we can:\n",
    "#   - create a new dictionary {new_ket: old_ket}\n",
    "#   - map amplitude of old_ket to new_ket in a new statevector:\n",
    "#       new_statevector[new_ket] = old_statevector[old_ket]\n",
    "# this approach will keep kets \"in order\" in new statevector\n",
    "# use list comprehension to create {new_ket: old_ket} dictionary from \n",
    "# statevector.keys()\n",
    "\n",
    "# create new dictionary mapping\n",
    "# note:  can this be done with Python map() method?\n",
    "def basis_change_dict(statevector, source_ket):\n",
    "    dict = {\n",
    "        key: basis_change_ket(key, source_ket) for key in statevector.keys()\n",
    "    }\n",
    "    return dict\n",
    "\n",
    "basis_change_dictionary = basis_change_dict(x, '1011')\n",
    "\n",
    "print(x)\n",
    "print(basis_change_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0, '0001': 2, '0010': 3, '0011': 5, '0100': 0, '0101': 7, '0110': 8, '0111': 9, '1000': 0, '1001': 11, '1010': 0, '1011': 13, '1100': 17, '1101': 19, '1110': 0, '1111': 1}\n",
      "{'0000': 13, '0001': 0, '0010': 11, '0011': 0, '0100': 1, '0101': 0, '0110': 19, '0111': 17, '1000': 5, '1001': 3, '1010': 2, '1011': 0, '1100': 9, '1101': 8, '1110': 7, '1111': 0}\n"
     ]
    }
   ],
   "source": [
    "# map amplitude of old_ket to new_ket in a new statevector:\n",
    "#   new_statevector[new_ket] = old_statevector[old_ket]\n",
    "\n",
    "number_qubits = 4\n",
    "\n",
    "def map_amplitudes(old_statevector, dict: dict) -> dict:\n",
    "    new_statevector = Statevector(np.ones(2**number_qubits)).to_dict()\n",
    "    for key in new_statevector.keys():\n",
    "        new_statevector[key] = old_statevector[dict[key]]\n",
    "    return new_statevector\n",
    "\n",
    "new_statevector_two = map_amplitudes(x, basis_change_dictionary)\n",
    "\n",
    "print(x)\n",
    "print(new_statevector_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0000'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'0'*number_qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# method to be written:\n",
    "# \tsource_ket = prompt user for source_ket to map to zero ket\n",
    "# \t'empty' user response randomly chooses a non-zero ket\n",
    "\n",
    "# Generate a list of kets for user to choose for basis transformation\n",
    "def get_valid_kets(statevector) -> tuple:\n",
    "    # generate a list of valid kets with non-zero amplitudes\n",
    "    valid_kets = [\n",
    "        key for (key, value) in statevector.items() if value != 0\n",
    "        ]\n",
    "    \n",
    "    # empty string is a valid input that will trigger random selection\n",
    "    # valid_kets.append(\"\")\n",
    "\n",
    "    return tuple(valid_kets)\n",
    "\n",
    "# Get source_ket via user input\n",
    "def get_source_ket(valid_kets: tuple, recursive=False):\n",
    "    \"\"\" get a ket string from user input\n",
    "    \"\"\"\n",
    "\n",
    "    # get user input\n",
    "    if recursive:\n",
    "        message = f\"\"\"Error: please choose a ket from the following list: \\n \n",
    "                    (Press Enter to choose a random ket) \\n\"\"\"\n",
    "    else:\n",
    "        message = f\"\"\"Please choose a ket to map to the zero ket: \\n \n",
    "                    (Press Enter to choose a random ket) \\n\"\"\"\n",
    "    \n",
    "    # display list of valid kets\n",
    "    print(valid_kets)\n",
    "\n",
    "    try:\n",
    "        # get user input and convert to string\n",
    "        source_ket = str(input(message))    \n",
    "        \n",
    "        # empty user input chooses random ket from valid_kets\n",
    "        if source_ket == \"\":\n",
    "            source_ket = np.random.choice(valid_kets)\n",
    "            print(\"Random Choice: \" + source_ket)\n",
    "        # check if user input is in valid_kets\n",
    "        elif source_ket not in valid_kets:\n",
    "            raise ValueError\n",
    "    except ValueError:\n",
    "        return get_source_ket(valid_kets, True)\n",
    "            \n",
    "    return source_ket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('0001', '0010', '0011', '0101', '0110', '0111', '1001', '1011', '1100', '1101', '1111')\n"
     ]
    }
   ],
   "source": [
    "# notes: https://stackoverflow.com/questions/37751273/exception-handling-with-boolean-expressions\n",
    "\n",
    "valid_kets = get_valid_kets(x)\n",
    "\n",
    "print(valid_kets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('0001', '0010', '0011', '0101', '0110', '0111', '1001', '1011', '1100', '1101', '1111')\n",
      "Random Choice: 1111\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'1111'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_source_ket(valid_kets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('0001', '0010', '0011', '0101', '0110', '0111', '1001', '1011', '1100', '1101', '1111')\n",
      "('0001', '0010', '0011', '0101', '0110', '0111', '1001', '1011', '1100', '1101')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'1011'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random choice:\n",
    "# https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html\n",
    "# https://pynative.com/python-random-choice/#h-random-choice-function-to-select-a-random-element-from-a-list-in-python\n",
    "\n",
    "print(valid_kets)\n",
    "np.random.choice(valid_kets)"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}