Jordan-Wigner encoding-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jordan-Wigner encoding\n",
    "### 1 Qubit\n",
    "Jordan-Wigner enoding is a method for fermionic creation and annihilation operations.\n",
    "Let's start from one-qubit operations.\n",
    "Q is an annihilation operator, and Q+ is a creation operator.\n",
    "|0> is a vacancy state and |1> is a occupied state. In the first part, we will apply the operators Q and Q+ on |0> and |1> states and demonstrate the results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "annihilation operation on vancy state :\n",
      "[0.+0.j 0.+0.j] which means the state disappeared!\n",
      "annihilation operation on occupied state :\n",
      "[1.+0.j 0.+0.j] , meaning |0> -> |1>\n",
      "creation operation on vancy state :\n",
      "[0.+0.j 1.+0.j] , meaning |0> -> |1>\n",
      "annihilation operation on occupied state :\n",
      "[0.+0.j 0.+0.j] which means the state disappeared!\n"
     ]
    }
   ],
   "source": [
    "# Define the vacancy and the occupied states\n",
    "vacancy = np.array([1,0])\n",
    "occupied = np.array([0,1])\n",
    "\n",
    "# Q = |0><1| = (X+iY)/2\n",
    "Q = (np.array([[0,1],[1,0]]) + 1j*np.array([[0,-1j],[1j,0]]))/2\n",
    "\n",
    "# Q|0>\n",
    "annilation_zero = np.dot(Q,vacancy)\n",
    "# Q|1>\n",
    "annilation_one = np.dot(Q,occupied)\n",
    "\n",
    "#print the output\n",
    "print(\"annihilation operation on vancy state :\")\n",
    "print(annilation_zero, \"which means the state disappeared!\")\n",
    "print(\"annihilation operation on occupied state :\")\n",
    "print(annilation_one, \", meaning |0> -> |1>\")\n",
    "\n",
    "# Q_dagger = |0><1| = (X-iY)/2\n",
    "Q_dagger = (np.array([[0,1],[1,0]]) - 1j*np.array([[0,-1j],[1j,0]]))/2\n",
    "\n",
    "# Q|0>\n",
    "creation_dagger_zero = np.dot(Q_dagger,vacancy)\n",
    "# Q|1>\n",
    "creation_dagger_one = np.dot(Q_dagger,occupied)\n",
    "\n",
    "#print the output\n",
    "print(\"creation operation on vancy state :\")\n",
    "print(creation_dagger_zero, \", meaning |0> -> |1>\")\n",
    "print(\"annihilation operation on occupied state :\")\n",
    "print(creation_dagger_one, \"which means the state disappeared!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Qubits\n",
    "\n",
    "Jordan-Wigner enoding is a method for fermionic creation and annihilation operations. \n",
    "In this section a two-fermion system represented by two qubits will be presented.  \n",
    "There will be creation operations and annihilation operations applied on q1 or q2. \n",
    "\n",
    "\n",
    "|q1q2> will be initialized as either |00>, |01>, |10> or |11> and after the operations applied on the qubits, the results are shown as follow.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "annihilation on q1 for |10>: [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      "annihilation on q1 for |11>: [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      "annihilation on q2 for |01>: [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      "annihilation on q2 for |11>: [ 0.+0.j  0.+0.j -1.+0.j  0.+0.j]\n",
      "--------------------------------------------------------------\n",
      "creation on q1 for |00>: [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      "creation on q1 for |01>: [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      "creation on q2 for |00>: [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      "creation on q2 for |10>: [ 0.+0.j  0.+0.j  0.+0.j -1.+0.j]\n"
     ]
    }
   ],
   "source": [
    "##|q1q2> states\n",
    "\n",
    "#create a 4X1 vector |00>\n",
    "qubits00 = np.array([1,0,0,0])\n",
    "#create a 4X1 vector |01>\n",
    "qubits01 = np.array([0,1,0,0])\n",
    "#create a 4X1 vector |10>\n",
    "qubits10 = np.array([0,0,1,0])\n",
    "#create a 4X1 vector |11>\n",
    "qubits11 = np.array([0,0,0,1])\n",
    "\n",
    "\n",
    "##Operator definition\n",
    "\n",
    "# Pauli z\n",
    "z = np.array([[1,0],[0,-1]])\n",
    "#create a 4X4 Q(annihilation) matrix on q1\n",
    "Q1_four = np.kron(Q,np.eye(2)) # annihilation on q1   \n",
    "#create a 4X4 Q(annihilation) matrix on q2\n",
    "Q2_four = np.kron(z,Q) # annihilation on q2    \n",
    "\n",
    "#create a 4X4 Q+(creation) matrix on q1\n",
    "Q1_dagger_four = np.kron(Q_dagger,np.eye(2)) # creation on q1\n",
    "#create a 4X4 Q+(creation) matrix on q2\n",
    "Q2_dagger_four = np.kron(z,Q_dagger) # creation on q2\n",
    "\n",
    "\n",
    "##Annihilation\n",
    "\n",
    "# annihilation on q1 for |10>\n",
    "annih_q1_qubits10 = np.dot(Q1_four, qubits10)\n",
    "print(\"annihilation on q1 for |10>:\", annih_q1_qubits10)\n",
    "\n",
    "# annihilation on q1 for |11>\n",
    "annih_q1_qubits01 = np.dot(Q1_four, qubits11)\n",
    "print(\"annihilation on q1 for |11>:\", annih_q1_qubits01)\n",
    "\n",
    "# annihilation on q2 for |01>\n",
    "annih_q2_qubits01 = np.dot(Q2_four, qubits01)\n",
    "print(\"annihilation on q2 for |01>:\", annih_q2_qubits01)\n",
    "\n",
    "# annihilation on q2 for |11>\n",
    "annih_q2_qubits11 = np.dot(Q2_four, qubits11)\n",
    "print(\"annihilation on q2 for |11>:\", annih_q2_qubits11)\n",
    "\n",
    "print(\"--------------------------------------------------------------\")\n",
    "\n",
    "##Creation\n",
    "\n",
    "# creation on q1 for |00>\n",
    "create_q1_qubits00 = np.dot(Q1_dagger_four, qubits00)\n",
    "print(\"creation on q1 for |00>:\", create_q1_qubits00)\n",
    "\n",
    "# creation on q1 for |01>\n",
    "create_q1_qubits01 = np.dot(Q1_dagger_four, qubits01)\n",
    "print(\"creation on q1 for |01>:\", create_q1_qubits01)\n",
    "\n",
    "# creation on q2 for |00>\n",
    "create_q2_qubits00 = np.dot(Q2_dagger_four, qubits00)\n",
    "print(\"creation on q2 for |00>:\", create_q2_qubits00)\n",
    "\n",
    "# creation on q2 for |10>\n",
    "create_q2_qubits10 = np.dot(Q2_dagger_four, qubits10)\n",
    "print(\"creation on q2 for |10>:\", create_q2_qubits10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trivial Hamiltonian for 2 qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.+0.j 0.+0.j 0.+0.j 2.+0.j] : Hamiltonian on |11>\n"
     ]
    }
   ],
   "source": [
    "## Hamiltonian \n",
    "epsilon = 1\n",
    "H = epsilon* (np.dot(Q1_dagger_four, Q1_four) + np.dot(Q2_dagger_four, Q2_four))\n",
    "\n",
    "# Hamiltonian on |11>\n",
    "H_11 = np.dot(H, qubits11)   \n",
    "print(H_11, \": Hamiltonian on |11>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #create a 16X16 Q matrix\n",
    "# Q_eight = np.kron(Q_four,np.eye(2))\n",
    "# Q_sixteen = np.kron(Q_eight,np.eye(2))\n",
    "# print(\"16X16 Q matrix:\")\n",
    "# print(Q_sixteen)\n",
    "\n",
    "# #create a 16X16 Q+ matrix\n",
    "# Q_dagger_eight = np.kron(Q_dagger_four,np.eye(2))\n",
    "# Q_dagger_sixteen = np.kron(Q_dagger_eight,np.eye(2))\n",
    "# print(\"16X16 Q+ matrix:\")\n",
    "# print(Q_dagger_sixteen)\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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}