entanglement_criteria_third_draft.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.quantum_info import random_statevector\n",
    "# from functools import reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To Do\n",
    "\n",
    "1. Update Criteria to normalize Psi\n",
    "   1. 0 ket should have amplitude '1'\n",
    "   2. or, divide all amplitudes by 0 ket amplitude\n",
    "2. Finish decimal indices version\n",
    "3. ~~Copy main functions to new notebook~~\n",
    "4. Basis Change? Choose any ket from which to perform bit flip/basis change\n",
    "   1. This is an equivalence relation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entanglement Criteria\n",
    "\n",
    "## Full Algorithm\n",
    "\n",
    "Input: a Statevector $|\\psi\\rangle$\n",
    "- https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.html\n",
    "- See Initialization of Statevectors (below)\n",
    "- Algorithm only applies to Statevectors of size $2^n$ from a vector space $V^{\\otimes n}$\n",
    "- Note: Statevector will store amplitude of 0 for any kets whose amplitudes are not provided\n",
    "  \n",
    "1. Get n = number of qubits per ket\n",
    "2. Get list of all basis-kets of length n\n",
    "3. Get list of all non-basis kets of length n\n",
    "4. For each non-basis ket:\n",
    "   1. Get list of corresponding basis-kets\n",
    "   2. Apply Criteria\n",
    "   3. Record Results\n",
    "5. If False occurs in Results, print \"Entangled\" message, Else Print \"Not Entangled\" message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determine All Basis Kets\n",
    "\n",
    "Input: n = number of qubits per ket\n",
    "\n",
    "1. Generate a list of powers of two from $2^0$ to $2^{n-1}$\n",
    "2. Generate a list of kets `list(Psi.keys())` from Statevector dictionary keys\n",
    "3. Use powers of two to reference basis kets in list of kets and create a new\n",
    "   list of basis kets\n",
    "\n",
    "### Determine All Non-Basis Kets\n",
    "\n",
    "Input: list of basis kets, list of dictionary keys\n",
    "\n",
    "1. Copy the list of dictionary keys, excluding all basis kets\n",
    "\n",
    "### Determine Basis Kets corresponding to each Non-Basis Ket\n",
    "\n",
    "Input: list of non-basis kets\n",
    "\n",
    "For each ket:\n",
    "\n",
    "1. For each bit of ketstring, check if bit is equal to '1'\n",
    "2. If True, record index of bit\n",
    "3. The corresponding basis ket is stored with same index in basis kets list\n",
    "4. Generate a list of corresponding basis kets from all such indices\n",
    "5. Store list in a dictionary indexed by key `'basis kets'`\n",
    "\n",
    "### Create Dictionary of all Non-Basis Kets\n",
    "\n",
    "1. Create dictionary with non-basis kets as keys\n",
    "2. Values are the corresponding basis ket dictionary for each ket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criteria\n",
    "\n",
    "Input: a non-basis ket index (decimal k or binary b)\n",
    "\n",
    "1. If not provided, determine corresponding basis kets\n",
    "2. Check if product of basis ket amplitudes = non-basis ket amplitude\n",
    "3. Return dictionary with target amplitude and boolean result\n",
    "4. If this is running for entire statevector, append these values to \n",
    "   non-basis ket dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Below only applies to `check_single_ket()` function when basis_kets are not provided**\n",
    "\n",
    "#### Method 1: Binary Basis Kets (for Qiskit Statevector Dictionary)\n",
    "Given a non-basis binary ketstring $b$ in $\\{0,1\\}^n$\n",
    "- for each index $i$, check if `b[i] == \"1\"`\n",
    "- when true:\n",
    "  - initialize a new string of length $n$\n",
    "  - use bitwise `|` to flip the bit at index $n-1-i$ (bitwise counts from R to L)\n",
    "  - store result in new list\n",
    "- the new list contains the $e_i$ basis ket strings corresponding to $b$\n",
    "  \n",
    "#### Method 2: Decimal Indices (for Qiskit Statevector)\n",
    "Given a non-basis binary ketstring $b$ in $\\{0,1\\}^n$\n",
    "- for each index $i$, check if `b[i] == \"1\"`\n",
    "- when true:\n",
    "  - append $i$ to a new list of indices\n",
    "  - subtract each $i$ from $n-1$\n",
    "- this new list is the place value exponents of 2 represented by each basis string\n",
    "- create a new list of powers of 2 from the list of exponents\n",
    "- The list of powers of 2 are the decimal indices corresponding to basis kets\n",
    "- `int(b, 2)` gives the decimal index for $b$ in the Statevector\n",
    "\n",
    "#### Check Product of Basis Ket Amplitudes\n",
    "\n",
    "Input: list of basis ket indices\n",
    "\n",
    "##### Using binary indices\n",
    "1. Initialize product = 1\n",
    "2. For all i in index_list:\n",
    "   1. product = product*Statevector.to_dict[index]\n",
    "   2. check whether product == Statevector.to_dict[b]\n",
    "\n",
    "##### Using decimal indices\n",
    "1. Initialize product = 1\n",
    "2. For all i in index_list:\n",
    "   1. product = product*Statevector[2^(n-1-i)]\n",
    "3. check whether product == Statevector[k]\n",
    "\n",
    "#### Notes\n",
    "1. The values $2^{(n-1-i)}$ are indices that reference the amplitudes of the basis kets in the Qiskit `Statevector`.\n",
    "   and reference binary keys in `list(Statevector.to_dict().keys())`.\n",
    "2. The binary keys reference the basis ket amplitudes in `Statevector.to_dict()`.\n",
    "3. For Statevectors of $n$ qubits of arbitrary length, a Qiskit Statevector can have many different subsystems\n",
    "   - We can still embed the Statevector in a span of $2^n$ elements\n",
    "   - Need to discuss what Entanglement means in this case\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1000', '0100', '0010', '0001']\n",
      "['0011', '0101', '0110', '0111', '1001', '1010', '1011', '1100', '1101', '1110', '1111']\n"
     ]
    }
   ],
   "source": [
    "# Get list of Powers of Two in Binary or Decimal up to 2**(n-1)\n",
    "# input: n = number of qubits, base (optional)\n",
    "# output: list of powers of two up to 2**(number_qubits-1)\n",
    "\n",
    "def powers_of_two(n, base=None):\n",
    "    if base == 10:\n",
    "        return [2**(n-1-i) for i in range(n)]\n",
    "    else:\n",
    "        return [format(1 << (n - 1 - i) | 0, '0'+str(n)+'b') for i in range(n)]\n",
    "\n",
    "\n",
    "# Get list of Non-Basis Kets in Binary or Decimal\n",
    "# input: n = number of qubits, list of powers of 2, base (optional)\n",
    "# output: list of non-basis kets\n",
    "\n",
    "def non_basis_kets(n, powers, base=None):\n",
    "    if base == 10:\n",
    "        non_basis_kets = [i for i in range(1,2**n) if i not in powers]\n",
    "    else:\n",
    "        non_basis_kets = [ket for ket in list(Psi.keys())[1:] if ket not in powers]\n",
    "        \n",
    "    return non_basis_kets\n",
    "\n",
    "\n",
    "# test\n",
    "number_qubits = 4\n",
    "base = None\n",
    "\n",
    "powers = powers_of_two(number_qubits, base)\n",
    "print(powers)\n",
    "\n",
    "non_basis_kets_list = non_basis_kets(number_qubits, powers, base)\n",
    "print(non_basis_kets_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine Basis Kets (binary)\n",
    "# input:    \n",
    "#   ket = non-basis ket\n",
    "#   powers = list of all basis kets\n",
    "# output:\n",
    "#   list of basis kets\n",
    "\n",
    "def get_basis_kets(ket, powers):\n",
    "    basis_kets = [powers[index] for index, bit in enumerate(ket) if bit == \"1\"]\n",
    "    return basis_kets\n",
    "\n",
    "# Determine Basis Kets (decimal)\n",
    "# creates a list of basis kets indices corresponding to non-basis ket\n",
    "# input:\n",
    "#   powers = list of powers of two\n",
    "#   k = non-basis ket index\n",
    "# output:\n",
    "#   list of basis ket indices\n",
    "\n",
    "def get_basis_indices(k, powers):\n",
    "    k_list = []\n",
    "    for p in powers:\n",
    "        if k < p:\n",
    "            pass\n",
    "        else:\n",
    "            k = k - p\n",
    "            k_list.append(p)\n",
    "    return k_list    \n",
    "\n",
    "# test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0011': {'basis_kets': ['0010', '0001']}, '0101': {'basis_kets': ['0100', '0001']}, '0110': {'basis_kets': ['0100', '0010']}, '0111': {'basis_kets': ['0100', '0010', '0001']}, '1001': {'basis_kets': ['1000', '0001']}, '1010': {'basis_kets': ['1000', '0010']}, '1011': {'basis_kets': ['1000', '0010', '0001']}, '1100': {'basis_kets': ['1000', '0100']}, '1101': {'basis_kets': ['1000', '0100', '0001']}, '1110': {'basis_kets': ['1000', '0100', '0010']}, '1111': {'basis_kets': ['1000', '0100', '0010', '0001']}}\n"
     ]
    }
   ],
   "source": [
    "# Create a dictionary indexed by all non-basis kets in Psi\n",
    "#   initialize values as dictionaries of lists of corresponding of basis kets\n",
    "# input:\n",
    "#   list of non-basis kets (binary) or non-basis ket indices (decimal)\n",
    "#   list of all basis kets (binary) or ket indices (decimal)\n",
    "# output:\n",
    "#   dictionary\n",
    "\n",
    "def non_basis_kets_dict(list, powers, base=None):\n",
    "    # list = list of non-basis kets or indices\n",
    "    # powers = list of basis kets or powers of 2\n",
    "    # base = 10 for indices output\n",
    "    dict = {}\n",
    "    if base == 10:\n",
    "        # decimal function\n",
    "        get_kets = get_basis_indices\n",
    "    else:\n",
    "        # binary function\n",
    "        get_kets = get_basis_kets\n",
    "\n",
    "    for ket in list:\n",
    "        m = ket\n",
    "        basis_kets = get_kets(ket, powers)\n",
    "        dict[m] = { 'basis_kets': basis_kets }\n",
    "\n",
    "    return dict\n",
    "\n",
    "# test\n",
    "\n",
    "# binary\n",
    "dict = non_basis_kets_dict(non_basis_kets_list, powers)\n",
    "print(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply Basis Ket Amplitudes\n",
    "# input: statevector, list of basis kets (binary or decimal)\n",
    "# output: product of amplitudes indexed by basis kets in Statevector dictionary\n",
    "#           or basis ket indices in Statevector\n",
    "\n",
    "def basis_amplitude_product(statevector, index_list):\n",
    "    \"\"\" Works with decimal and binary indices \"\"\"\n",
    "    product = 1    \n",
    "    for index in index_list:\n",
    "        product = product*statevector[index]\n",
    "    return product\n",
    "\n",
    "\n",
    "# Equality check\n",
    "# input: two values\n",
    "# output: True or False\n",
    "# Make lambda function?\n",
    "\n",
    "def is_equal(a, b):\n",
    "    return a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given 1011, Method 1 returns the list ['1000', '0010', '0001']\n",
      "Given 1011, Method 2 returns the list [8, 2, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'basis_kets': ['1000', '0010', '0001'],\n",
       " 'target_amplitude': (1.815207830942379-3.376890393151645j),\n",
       " 'equality': False}"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# single ket check function (using binary keys)\n",
    "# input: statevector, ket, list of basis kets (optional)\n",
    "#   if basis kets not provided, it will generate them\n",
    "# output: dictionary with amplitude and boolean check value\n",
    "\n",
    "def check_single_ket(statevector, ket, basis_kets=None):\n",
    "    dict = {}\n",
    "        \n",
    "    if basis_kets == None:\n",
    "        basis_kets = generate_basis_kets(ket)\n",
    "        dict['basis_kets'] = basis_kets\n",
    "\n",
    "    # get product of basis ket amplitudes and add to dictionary\n",
    "    dict['target_amplitude'] = basis_amplitude_product(statevector, basis_kets)\n",
    "\n",
    "    # check if ket amplitude = product of basis ket amplitudes and add to dictionary\n",
    "    dict['equality'] = is_equal(statevector[ket], dict['target_amplitude'])\n",
    "\n",
    "    # Print Statements\n",
    "    def print_statements():\n",
    "        product_string = basis_product_string(basis_kets)\n",
    "        print_entanglement_equation(ket, product_string, dict['equality'])\n",
    "        if dict['equality'] == False:\n",
    "            print_basis_amplitudes(product_string, dict['target_amplitude'])\n",
    "    \n",
    "    # print_statements()\n",
    "    \n",
    "    return dict\n",
    "\n",
    "\n",
    "# Generate basis kets\n",
    "# Method 1 (binary)\n",
    "# Use with check_single_ket and Statevector Dictionary when basis_kets not provided\n",
    "# input: (binary) non-basis ket string\n",
    "# output: (binary) keys for basis kets in Statevector Dictionary\n",
    "def generate_basis_kets(ketstring):\n",
    "    length = len(ketstring)\n",
    "    basis_kets = [format(1 << (length - 1 - index) | 0, '0'+str(length)+'b')\n",
    "               for index, bit in enumerate(ketstring) if bit == \"1\"]    \n",
    "    return basis_kets\n",
    "\n",
    "# Generate basis indices\n",
    "# Method 2 (decimal)\n",
    "# Use with check_single_ket and Statevector when basis_kets not provided\n",
    "# input: (binary) non-basis ket string\n",
    "# ouput: (decima) indices for basis kets in Statevector\n",
    "def generate_basis_indices(ket):\n",
    "    indices = [2**(len(ket) - 1 - index) for index, bit in enumerate(ket) \n",
    "    if bit == \"1\"]\n",
    "    return indicies\n",
    "\n",
    "\n",
    "# Print Statements for check_single_ket()\n",
    "\n",
    "# Print Product of Basis Kets Expression\n",
    "# input: list of basis kets for a non-basis ket\n",
    "# output: string of product of Psi[basis_ket]\n",
    "def basis_product_string(list):\n",
    "    product = \"Psi['\"+list[0]+\"']\"\n",
    "    for index in list[1:]:\n",
    "        product = product + \"*Psi['\"+index+\"']\"\n",
    "    return product\n",
    "\n",
    "# Print Non-basis ket amplitude\n",
    "# input: non-basis ket, amplitude\n",
    "def print_ket_amplitude(ket, amplitude):\n",
    "    print(\"Psi['\"+ket+\"'] = \" + str(amplitude))\n",
    "\n",
    "# Print Product of Basis Kets Amplitude\n",
    "# input: product of basis ket string, amplitude\n",
    "def print_basis_amplitudes(kets, amplitude):\n",
    "    print(kets + \" = \" + str(amplitude))\n",
    "\n",
    "# Print True/False check statement\n",
    "# input: non-basis ket, product of basis ket string, boolean check value\n",
    "def print_entanglement_equation(ket, basis_elements, bool):\n",
    "    print(\"Psi['\"+ket+\"']\" + \" == \" + basis_elements + \" is \" + str(bool))\n",
    "\n",
    "# test generate basis ket with 4-qubit ket\n",
    "ketstring = '1011'\n",
    "\n",
    "# binary basis kets\n",
    "basis_kets = create_basis_kets(ketstring)\n",
    "print(\"Given \" + str(ketstring) + \", Method 1 returns the list \" + str(basis_kets))\n",
    "\n",
    "# decimal basis indices\n",
    "indices = ket_to_powers(ketstring)\n",
    "print(\"Given \" + str(ketstring) + \", Method 2 returns the list \" + str(indices))\n",
    "\n",
    "# test\n",
    "single_ket = check_single_ket(Psi, '1011')\n",
    "single_ket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Psi> is Entangled\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'0011': {'basis_kets': ['0010', '0001'],\n",
       "  'target_amplitude': (-1.8131728771753264+1.2768337324229941j),\n",
       "  'equality': False},\n",
       " '0101': {'basis_kets': ['0100', '0001'],\n",
       "  'target_amplitude': (1.4373792186376444+1.0694989959388226j),\n",
       "  'equality': False},\n",
       " '0110': {'basis_kets': ['0100', '0010'],\n",
       "  'target_amplitude': (2.388703565195332-2.0698270223130666j),\n",
       "  'equality': False},\n",
       " '0111': {'basis_kets': ['0100', '0010', '0001'],\n",
       "  'target_amplitude': (-1.1948854464441099-3.336198111268769j),\n",
       "  'equality': False},\n",
       " '1001': {'basis_kets': ['1000', '0001'],\n",
       "  'target_amplitude': (0.1818491638320242+1.929745058047091j),\n",
       "  'equality': False},\n",
       " '1010': {'basis_kets': ['1000', '0010'],\n",
       "  'target_amplitude': (3.3935787611518484+0.42004469055259785j),\n",
       "  'equality': False},\n",
       " '1011': {'basis_kets': ['1000', '0010', '0001'],\n",
       "  'target_amplitude': (1.815207830942379-3.376890393151645j),\n",
       "  'equality': False},\n",
       " '1100': {'basis_kets': ['1000', '0100'],\n",
       "  'target_amplitude': (-0.5337185484647919-2.7105316293649007j),\n",
       "  'equality': False},\n",
       " '1101': {'basis_kets': ['1000', '0100', '0001'],\n",
       "  'target_amplitude': (-3.049682817431465-0.5412769983059221j),\n",
       "  'equality': False},\n",
       " '1110': {'basis_kets': ['1000', '0100', '0010'],\n",
       "  'target_amplitude': (-2.0914019482707467+5.04815834199228j),\n",
       "  'equality': False},\n",
       " '1111': {'basis_kets': ['1000', '0100', '0010', '0001'],\n",
       "  'target_amplitude': (4.428622213294312+4.233192586790599j),\n",
       "  'equality': False}}"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Entanglement Function (binary kets)\n",
    "# input: Statevector Dictionary\n",
    "# output: dictionary \n",
    "#   keys: all non-basis kets\n",
    "#   values: dictionaries of corresponding basis kets, target amplitude, boolean check\n",
    "\n",
    "def entangled(statevector):\n",
    "    # get number of qubits\n",
    "    number_qubits = len(list(statevector.keys())[0])\n",
    "\n",
    "    # generate list of basis kets:\n",
    "    powers = powers_of_two(number_qubits)\n",
    "\n",
    "    # generate list of non-basis kets:        \n",
    "    non_basis_kets_list = non_basis_kets(number_qubits, powers)\n",
    "\n",
    "    # store all non-basis kets in dictionary:\n",
    "    dict = non_basis_kets_dict(non_basis_kets_list, powers)\n",
    "\n",
    "    # initalize booleans\n",
    "    booleans = set()\n",
    "\n",
    "    for ket in dict:\n",
    "        # get results fron check single ket:\n",
    "        ket_results = check_single_ket(\n",
    "            statevector, \n",
    "            ket, \n",
    "            dict[ket]['basis_kets']\n",
    "            )\n",
    "        # update dictionary with results:\n",
    "        dict[ket]['target_amplitude'] = ket_results['target_amplitude']\n",
    "        dict[ket]['equality'] = ket_results['equality']\n",
    "        # faster way to do this?  items()?\n",
    "        booleans.add(dict[ket]['equality'])\n",
    "\n",
    "    # conclusion\n",
    "    if False in booleans:\n",
    "        print(\"|Psi> is Entangled\")\n",
    "    else:\n",
    "        print(\"|Psi> is not Entangled\")\n",
    "\n",
    "    return dict\n",
    "\n",
    "results = entangled(Psi)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector([-0.18808617-0.1589944j ,  0.17075775-0.17173285j,\n",
      "              0.10138651+0.22976637j, -0.01480501+0.09208322j,\n",
      "             -0.07926826-0.28895903j, -0.08794139-0.15355775j,\n",
      "             -0.16583805-0.17470529j, -0.14651142-0.11028345j,\n",
      "              0.05402964+0.35868494j,  0.31217184+0.0476259j ,\n",
      "              0.0824692 -0.21815926j, -0.01079228-0.23770372j,\n",
      "              0.05027123-0.00191067j,  0.034295  +0.42969689j,\n",
      "              0.06181807-0.0499862j ,  0.23662971+0.05664917j],\n",
      "            dims=(2, 2, 2, 2))\n",
      "number of qubits = 4\n",
      "target index = 15\n",
      "basis indices = [8, 4, 2, 1]\n",
      "target_amplitude = (0.23662970843003236+0.056649168796742j)\n"
     ]
    }
   ],
   "source": [
    "# TO DO\n",
    "# Entanglement Function (decimal indices)\n",
    "# input: Statevector\n",
    "# output: dictionary \n",
    "#   keys: all non-basis ket indices\n",
    "#   values: dictionaries of corresponding basis kets indices, target amplitude, \n",
    "#           boolean check\n",
    "\n",
    "def entangled(statevector, ket=''):\n",
    "    pass\n",
    "\n",
    "def check_single_ket(statevector, ket):      \n",
    "    \"\"\" Number of qubits per ket \"\"\"\n",
    "    number_qubits = len(ket)\n",
    "    print(\"number of qubits = \" + str(number_qubits))\n",
    "    \n",
    "\n",
    "    ### Using decimal indices\n",
    "    \"\"\" Convert binary target ket string to statevector decimal index \"\"\"\n",
    "    decimal_index = int(ket, 2)\n",
    "    print(\"target index = \" + str(decimal_index))\n",
    "    \n",
    "    \"\"\" Get Statevector decimal indices for corresponding basis elements \"\"\"\n",
    "    basis_indices = ket_to_powers(ket)\n",
    "    print(\"basis indices = \" + str(basis_indices))\n",
    "\n",
    "    \"\"\" Get target amplitude from Statevector \"\"\"\n",
    "    target_amplitude = statevector[decimal_index]\n",
    "    print(\"target_amplitude = \" + str(target_amplitude))\n",
    "    \n",
    "    \"\"\" Get product of basis ket amplitudes \"\"\"\n",
    "    product_basis_amplitudes = basis_amplitude_product(statevector, basis_indices)\n",
    "    \n",
    "number_qubits = 4\n",
    "dims = 2**number_qubits\n",
    "random_state = random_statevector(dims, None)\n",
    "print(random_state)\n",
    "\n",
    "check_single_ket(random_state, '1111')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Statevector\n",
    "\n",
    "### Option 1\n",
    "- For an n-qubit state, initialize an array of amplitudes of size \n",
    "  $2^n$\n",
    "- Convert the array to Qiskit Statevector `psi`\n",
    "- Convert the array to Qiskit Statevector dictionary `Psi`\n",
    "\n",
    "### Option 2\n",
    "- For an n-qubit state, initialize a nonzero array of size $2^n$, e.g. `np.ones(2**n)`\n",
    "- Convert the array to a Qiskit Statevector `psi`\n",
    "- Convert Statevector to Qiskit Statevector dictionary `Psi`\n",
    "- Populate the values of the Statevector dictionary with desired amplitudes\n",
    "\n",
    "### Option 3\n",
    "- Generate Qiskit random statevector\n",
    "  \n",
    "### Notes\n",
    "The decimal indices of a Qiskit `Statevector` correspond to binary string \n",
    "keys in a Qiskit Statevector.to_dict() dictionary, e.g. \n",
    "`Statevector[5]` is the same as `Statevector.to_dict()['101']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector([ 1.+0.j,  1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  5.+0.j,  6.+0.j,\n",
      "              7.+0.j,  8.+0.j,  9.+0.j, 10.+0.j, 11.+0.j, 12.+0.j, 13.+0.j,\n",
      "             14.+0.j, 15.+0.j],\n",
      "            dims=(2, 2, 2, 2))\n",
      "{'0000': (1+0j), '0001': (1+0j), '0010': (2+0j), '0011': (3+0j), '0100': (4+0j), '0101': (5+0j), '0110': (6+0j), '0111': (7+0j), '1000': (8+0j), '1001': (9+0j), '1010': (10+0j), '1011': (11+0j), '1100': (12+0j), '1101': (13+0j), '1110': (14+0j), '1111': (15+0j)}\n"
     ]
    }
   ],
   "source": [
    "# Option 1\n",
    "\n",
    "# Example: Initialize a list of amplitudes equal to the list index\n",
    "number_qubits = 4\n",
    "amplitudes = [i for i in range(2**number_qubits)]    \n",
    "\n",
    "# change zero ket amplitude to 1 to maintain our normalized zero ket condition\n",
    "amplitudes[0] = 1\n",
    "\n",
    "# create Statevector\n",
    "psi = Statevector(amplitudes)\n",
    "print(psi)\n",
    "\n",
    "# Convert Statevector to dictionary\n",
    "Psi = psi.to_dict()\n",
    "print(Psi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+0j)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'0000': (1+0j),\n",
       " '0001': (2+0j),\n",
       " '0010': (3+0j),\n",
       " '0011': (4+0j),\n",
       " '0100': (5+0j),\n",
       " '0101': (6+0j),\n",
       " '0110': (7+0j),\n",
       " '0111': (8+0j),\n",
       " '1000': 0j,\n",
       " '1001': (2+0j),\n",
       " '1010': (452345+0j),\n",
       " '1011': (2+0j),\n",
       " '1100': (34+0j),\n",
       " '1101': 0j,\n",
       " '1110': 0j,\n",
       " '1111': 0j}"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Option 2: Initialize Qiskit Statevector Dictionary and get amplitudes by user input\n",
    "\n",
    "# Get amplitude of single ket\n",
    "def getAmplitude(key, recursive=False):\n",
    "    \"\"\" get ket amplitude by user input \n",
    "    checks if input is a number\n",
    "    \"\"\"\n",
    "    if recursive:\n",
    "        message = \"Error: amplitude for \" + str(key) + \" must be a number: \"\n",
    "    else:\n",
    "        message = \"Enter an amplitude for \" + str(key) + \": \"\n",
    "    \n",
    "    amplitude = input(message)\n",
    "    \n",
    "    if amplitude == \"\":\n",
    "        amplitude = 0\n",
    "\n",
    "    try:\n",
    "        amplitude = complex(amplitude)\n",
    "    except ValueError:\n",
    "        return getAmplitude(key, True)\n",
    "    \n",
    "    return amplitude\n",
    "\n",
    "# Get amplitudes for all kets in Statevector\n",
    "def getAmplitudes(n):\n",
    "    # n = number of qubits\n",
    "    \"\"\" Initialize nonzero Qiskit Statevector Dictionary of length 2^n \"\"\"\n",
    "    amplitudes = np.ones(2**n)\n",
    "    statevector=Statevector(amplitudes).to_dict()\n",
    "    \"\"\" Get amplitudes for each ket by user input \"\"\"\n",
    "    for key in statevector.keys():\n",
    "        amplitude = getAmplitude(key)\n",
    "        statevector[key] = amplitude    \n",
    "    return statevector\n",
    "\n",
    "\n",
    "#test\n",
    "\n",
    "output = getAmplitude(1011)\n",
    "print(output)\n",
    "type(output)\n",
    "\n",
    "statevector = getAmplitudes()\n",
    "statevector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector([-0.13661694+0.08832346j,  0.03692219+0.17861878j,\n",
      "              0.32174689+0.00426943j,  0.15873036-0.12358027j,\n",
      "             -0.0778907 -0.24801729j, -0.05862798-0.04422403j,\n",
      "             -0.18884515-0.23859819j, -0.28569308+0.1329396j ,\n",
      "              0.14286887-0.24225273j, -0.25718291-0.23695628j,\n",
      "             -0.00216963-0.0791075j , -0.07830399+0.19622163j,\n",
      "             -0.02750064+0.31545799j,  0.06445611+0.11233476j,\n",
      "             -0.04618961-0.39892949j,  0.00388507+0.02791338j],\n",
      "            dims=(2, 2, 2, 2))\n",
      "Statevector([ 1.        -2.27460515e-17j,  0.40551451-1.04527546e+00j,\n",
      "             -1.64665106-1.09581830e+00j, -1.23181638+1.08200282e-01j,\n",
      "             -0.4256362 +1.54024555e+00j,  0.15505465+4.23951768e-01j,\n",
      "              0.17855995+1.86191572e+00j,  1.91844984+2.67203468e-01j,\n",
      "             -1.54598767+7.73738237e-01j,  0.53680808+2.08150632e+00j,\n",
      "             -0.25280877+4.15604046e-01j,  1.05907384-7.51594680e-01j,\n",
      "              1.19475264-1.53665644e+00j,  0.04216847-7.94998773e-01j,\n",
      "             -1.09292675+2.21347673e+00j,  0.0731012 -1.57058322e-01j],\n",
      "            dims=(2, 2, 2, 2))\n",
      "{'0000': (1-2.274605151448557e-17j), '0001': (0.40551450830647084-1.0452754625632519j), '0010': (-1.6466510631771998-1.095818300498357j), '0011': (-1.2318163777131839+0.10820028206296772j), '0100': (-0.4256362048521206+1.540245545435121j), '0101': (0.15505465335340451+0.4239517678553989j), '0110': (0.17855994779166495+1.8619157156755743j), '0111': (1.9184498388122633+0.26720346772595427j), '1000': (-1.5459876703311153+0.7737382372211501j), '1001': (0.5368080812107126+2.081506317621638j), '1010': (-0.2528087733010835+0.41560404605858897j), '1011': (1.0590738401556157-0.7515946802222746j), '1100': (1.1947526402657858-1.5366564428678726j), '1101': (0.042168473204012555-0.7949987734621023j), '1110': (-1.0929267497973543+2.213476728566005j), '1111': (0.0731011998353285-0.1570583215075342j)}\n"
     ]
    }
   ],
   "source": [
    "# Option 3\n",
    "\n",
    "# Example: generate random state vector:\n",
    "# https://entangledquery.com/t/how-to-generate-a-random-state-in-qiskit/21/\n",
    "\n",
    "# Qiskit Quantum Information library:\n",
    "# https://qiskit.org/documentation/apidoc/quantum_info.html\n",
    "\n",
    "number_qubits = 4\n",
    "dims = 2**number_qubits\n",
    "      \n",
    "random_state = random_statevector(dims, None)\n",
    "print(random_state)\n",
    "\n",
    "# Normalize zero ket to have amplitude = 1\n",
    "normalized_random_state = random_state/random_state[0]\n",
    "print(normalized_random_state)\n",
    "\n",
    "# Convert normalized Statevector to dictionary:\n",
    "Psi = normalized_random_state.to_dict()\n",
    "print(Psi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Entanglement Criteria for 2 qubits\n",
    "# Psi[\"01\"]*Psi[\"10\"] == Psi[\"11\"]*Psi[\"00\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['00001000', '00000010', '00000001']\n"
     ]
    }
   ],
   "source": [
    "# Convert list of decimals into binary strings of given length\n",
    "# input: list of decimals, desired length of binary string\n",
    "# output: binary strings padded with leading zeros to match desired length\n",
    "\n",
    "def build_binary_string(list, length):\n",
    "    \"\"\" Convert decimal ints to binary strings and pad strings with leading \n",
    "    zeros.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    list : int\n",
    "        Decimal values.\n",
    "    length: int\n",
    "        Number of qubits.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list : str\n",
    "       Binary strings with padded zeros to reach specified length.\n",
    "    \"\"\"\n",
    "    kets = [format(entry, '0'+str(length)+'b') for entry in list]\n",
    "        \n",
    "    return kets\n",
    "\n",
    "# Generate list of binary strings of length n from list of decimal indices\n",
    "number_qubits = 8\n",
    "kets_list = build_binary_string(indices, number_qubits)\n",
    "print(kets_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0111\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'00000100'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Binary arithmetic\n",
    "0b10**4\n",
    "bin(0b10**4)\n",
    "\n",
    "# Convert decimal integer to binary and remove Python's two leading bits\n",
    "# Use Python format(number, '0nb') where n = length of desired bitstring\n",
    "\n",
    "\"\"\"\n",
    "def binary(number):\n",
    "    return bin(number)[2:]\n",
    "\n",
    "bitstring = binary(7)\n",
    "print(bitstring)\n",
    "\"\"\"\n",
    "\n",
    "# Python's format() method\n",
    "\n",
    "n = str(4)\n",
    "binary = format(7, '0'+n+'b')\n",
    "print(binary)\n",
    "\n",
    "format(1 << 2 | 0, '0'+'8'+'b')\n",
    "\n",
    "# type(bin(0b1011))\n",
    "# type(0b1011)"
   ]
  }
 ],
 "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"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}