{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5: Uncertainity Principle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 1, Page number 177"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in momentum is 1.65e-24 kg m/sec\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;      #plancks constant(J s)\n",
    "deltax=4*10**-10;   #uncertainity(m)\n",
    "\n",
    "#Calculations\n",
    "delta_px=h/deltax;    #uncertainity in momentum(kg m/sec)\n",
    "\n",
    "#Result\n",
    "print \"uncertainity in momentum is\",delta_px,\"kg m/sec\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 2, Page number 177"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in position is 0.02418 m\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;      #plancks constant(J s)\n",
    "m=9.1*10**-31;      #mass(kg)\n",
    "v=600;              #speed(m/s)\n",
    "deltapx=(0.005/100)*m*v;  #uncertainity in momentum(kg m/sec)\n",
    "\n",
    "#Calculations\n",
    "deltax=h/deltapx;    #uncertainity in position(m)\n",
    "\n",
    "#Result\n",
    "print \"uncertainity in position is\",round(deltax,5),\"m\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 3, Page number 177"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in momentum is 6.63e-23 kg m/sec\n",
      "uncertainity in velocity is 7.286 *10**7 m/sec\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.63*10**-34;      #plancks constant(J s)\n",
    "deltax=0.1*10**-10;   #uncertainity(m)\n",
    "m0=9.1*10**-31;      #mass(kg)\n",
    "\n",
    "#Calculations\n",
    "deltap=h/deltax;    #uncertainity in momentum(kg m/sec)\n",
    "deltav=deltap/m0;   #uncertainity in velocity(m/sec) \n",
    "\n",
    "#Result\n",
    "print \"uncertainity in momentum is\",deltap,\"kg m/sec\"\n",
    "print \"uncertainity in velocity is\",round(deltav/10**7,3),\"*10**7 m/sec\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 4, Page number 178"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in velocity is 1835\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "me=9.1*10**-31;      #mass of electron(kg)\n",
    "mp=1.67*10**-27;      #mass of proton(kg)\n",
    "\n",
    "#Calculations\n",
    "deltavebydeltavp=mp/me;    #uncertainity in velocity\n",
    "\n",
    "#Result\n",
    "print \"uncertainity in velocity is\",int(deltavebydeltavp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 5, Page number 178"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "smallest possible uncertainity in position is 0.0388 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;      #plancks constant(J s)\n",
    "v=3*10**7;           #velocity(m/sec)\n",
    "c=3*10**8;           #velocity of light(m/sec)\n",
    "m0=9*10**-31;        #mass(kg)\n",
    "\n",
    "#Calculations\n",
    "deltaxmin=h*math.sqrt(1-(v**2/c**2))/(2*math.pi*m0*v);   #smallest possible uncertainity in position(m)\n",
    "\n",
    "#Result\n",
    "print \"smallest possible uncertainity in position is\",round(deltaxmin*10**10,4),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 6, Page number 179"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimum uncertainity in velocity is 7.3 *10**5 m/s\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;      #plancks constant(J s)\n",
    "deltapmax=10**-9;   #uncertainity in momentum(kg m/sec)\n",
    "m=9*10**-31;        #mass(kg)\n",
    "\n",
    "#Calculations\n",
    "deltapmin=h/deltapmax;   #smallest possible uncertainity in momentum(kg m/sec)\n",
    "deltavxmin=deltapmin/m;  #minimum uncertainity in velocity(m/s) \n",
    "\n",
    "#Result\n",
    "print \"minimum uncertainity in velocity is\",round(deltavxmin/10**5,1),\"*10**5 m/s\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 7, Page number 179"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time required is 1.9 *10**-8 second\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;           #velocity of light(m/sec)\n",
    "lamda=6000*10**-10;  #wavelength(m)\n",
    "dlamda=10**-4*10**-10;    #width(m)\n",
    "\n",
    "#Calculations\n",
    "deltat=lamda**2/(2*math.pi*c*dlamda);     #time required(second)\n",
    "\n",
    "#Result\n",
    "print \"time required is\",round(deltat*10**8,1),\"*10**-8 second\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 8, Page number 180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in position is 3.381 *10**-6 m\n",
      "answer given in the book varies due to rounding off errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.63*10**-34;      #plancks constant(J s)\n",
    "m=9.1*10**-31;      #mass(kg)\n",
    "v=3.5*10**5;              #speed(m/s)\n",
    "deltap=(0.0098/100)*m*v;  #uncertainity in momentum(kg m/sec)\n",
    "\n",
    "#Calculations\n",
    "deltax=h/(2*math.pi*deltap);    #uncertainity in position(m)\n",
    "\n",
    "#Result\n",
    "print \"uncertainity in position is\",round(deltax*10**6,3),\"*10**-6 m\"\n",
    "print \"answer given in the book varies due to rounding off errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 9, Page number 180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uncertainity in momentum is 5.276 *10**-20 kg m/sec\n",
      "kinetic energy of electron is 9559.1 MeV\n",
      "answer for kinetic energy given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.63*10**-34;      #plancks constant(J s)\n",
    "m0=9.1*10**-31;      #mass(kg)\n",
    "deltax=2*10**-15;    #uncertainity in position(m)\n",
    "e=1.6*10**-19;       #charge(coulomb)\n",
    "\n",
    "#Calculations\n",
    "deltap=h/(2*math.pi*deltax);    #uncertainity in momentum(kg m/sec)\n",
    "K=deltap**2/(2*m0*e);           #kinetic energy of electron(eV)\n",
    "\n",
    "#Result\n",
    "print \"uncertainity in momentum is\",round(deltap*10**20,3),\"*10**-20 kg m/sec\"\n",
    "print \"kinetic energy of electron is\",round(K/10**6,1),\"MeV\"\n",
    "print \"answer for kinetic energy given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 10, Page number 180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimum uncertainity in momentum is 1.05e-20 kg m/sec\n",
      "minimum kinetic energy is 2.06 *10**5 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "chi=1.05*10**-34;      #plancks constant(J s)\n",
    "deltaxmax=2*5*10**-15; #uncertainity in momentum(kg m/sec)\n",
    "m=1.67*10**-27;        #mass(kg)\n",
    "e=1.6*10**-19;       #charge(coulomb)\n",
    "\n",
    "#Calculations\n",
    "deltapmin=chi/deltaxmax;      #minimum uncertainity in momentum(kg m/sec)\n",
    "Emin=deltapmin**2/(2*m*e);      #minimum kinetic energy(eV)\n",
    "\n",
    "#Result\n",
    "print \"minimum uncertainity in momentum is\",deltapmin,\"kg m/sec\"\n",
    "print \"minimum kinetic energy is\",round(Emin/10**5,2),\"*10**5 eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 11, Page number 181"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "angular orbital position is 10 radian\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=5/100;           #error\n",
    "h=1;               #assume\n",
    "\n",
    "#Calculations\n",
    "deltaJ=e*2*h;      #uncertainity in angular momentum\n",
    "delta_theta=h/deltaJ;     #angular orbital position(radian)\n",
    "\n",
    "#Result\n",
    "print \"angular orbital position is\",int(delta_theta),\"radian\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}