Sets and Probability.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MSDS 400 Sets and Probability\n",
    "\n",
    "The data for the following example are shown in the cell below. Various set operations will be performed. The first steps are to define the lists of data which will then be converted into set objects. Various set\n",
    "operations will be demonstrated. Finally, a set will be converted to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set([1, 2, 3]) is the same as {1, 2, 3}. The former is easier to read, but the later is about twice as fast for the CPU.\n",
    "U = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}\n",
    "A = {1, 2, 4, 5, 7}\n",
    "B = {2, 4, 5, 7, 9, 11}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following generates new variables only to facilitate printing.\n",
    "The variables Uab, AB, Ac, Bc, AsB, R, Add, Addc and SD are for my\n",
    "convenience only.  The important thing is to study the set operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of A and B = {1, 2, 4, 5, 7, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "Uab = A | B\n",
    "print('Union of A and B =', Uab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of A and B = {2, 4, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "AB = A & B\n",
    "print('Intersection of A and B =', AB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A complement = {3, 6, 8, 9, 10, 11}\n",
      "B complement = {1, 3, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "Ac = U - A\n",
    "Bc = U - B\n",
    "print('A complement =', Ac)\n",
    "print('B complement =', Bc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric difference of A and B =  {1, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "AsB = A ^ B  # Example of finding the symmetric difference of A and b. The symmetric difference are elements in A and B not common to both\n",
    "print('Symmetric difference of A and B = ', AsB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric difference by union and intersection = {1, 11, 9}\n"
     ]
    }
   ],
   "source": [
    "SD = (A | B) - (A & B)  # Example showing another way to obtain the symmetric difference\n",
    "print('Symmetric difference by union and intersection =', SD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of Ac, Bc and AB   {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}\n",
      "Original set U was  {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}\n"
     ]
    }
   ],
   "source": [
    "R = Ac | Bc | AB  # Union of several sets\n",
    "print('Union of Ac, Bc and AB  ', R)\n",
    "print('Original set U was ', U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated version of U =  {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}\n"
     ]
    }
   ],
   "source": [
    "Add = {12, 13, 14}  # Items can be added to sets using the union operation\n",
    "U = U | Add\n",
    "print('Updated version of U = ', U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original version of U = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}\n"
     ]
    }
   ],
   "source": [
    "Addc = U - Add  # Removal is possible using the complement operation\n",
    "U = U & Addc\n",
    "print('Original version of U =', U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U is now a list. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "U = list(U)  # Following these operations, a set may be converted to a list.\n",
    "print('U is now a list.', U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate the universe U.  Note that range(1,27,1) will be used to produce a list of 26 positive integers for set operations.  Remember, range() includes the first, i.e. 1, but not the last element, i.e. 27.  The third argument, 1, defines the step used between consecutive elements.  Note that the functions used in this module are available from Python itself.\n",
    "\n",
    "Slice the list U into three subsets.  Note that slicing is inclusive of the first indexed element and exclusive of the last indexed element.  Also, the first element has 0 for an index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The universe U is {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}\n",
      "A is {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}\n",
      "B is {14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}\n",
      "C is {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}\n"
     ]
    }
   ],
   "source": [
    "U = range(1, 27)\n",
    "A = U[0:13]\n",
    "B = U[13:]\n",
    "C = U[7:20]\n",
    "\n",
    "A = set(A)\n",
    "B = set(B)\n",
    "C = set(C)\n",
    "U = set(U)\n",
    "print('The universe U is', U)\n",
    "\n",
    "print('A is', A)  # Compare these sets to the slice statements above.\n",
    "print('B is', B)\n",
    "print('C is', C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is assumed in this module that each element of U occurs with equal probability as would be the case with random sampling with replacement. This assumption allows the probability of a set to be calculated as the ratio of the length of the set (i.e. number of elements) divided by the overall length of U which in this Module is 26.  Note that %r and %s both can be used with strings and lists.\n",
    "\n",
    "Convert the length of T to floating point to avoid interger division. The function round() was defined in earlier modules as was float()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of null intersection  0.0\n"
     ]
    }
   ],
   "source": [
    "T = float(len(U))\n",
    "\n",
    "Null = A & B  # Demonstrate the null intersection and probability.\n",
    "print('Probability of null intersection ', round((len(Null)/T), 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of A and C is  {8, 9, 10, 11, 12, 13}\n",
      "Union of A and C  {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}\n",
      "Probability of A union C =  0.769\n",
      "Result of Union Rule Summation = (0.7692307692307693, 3)\n"
     ]
    }
   ],
   "source": [
    "print('Intersection of A and C is ', (A & C))  # Demonstrate the Union Rule for Probability.\n",
    "print('Union of A and C ', (A | C))\n",
    "\n",
    "P = (len(A) + len(C) - len(A & C))\n",
    "print('Probability of A union C = ', round((len(A | C)/T), 3))\n",
    "print('Result of Union Rule Summation =', ((P/T), 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complement of C is {1, 2, 3, 4, 5, 6, 7, 21, 22, 23, 24, 25, 26}\n",
      "Odds of C are 1.0\n"
     ]
    }
   ],
   "source": [
    "# Demonstrate the calculation of Odds using the complement rule.\n",
    "print('Complement of C is', (U-C))\n",
    "print('Odds of C are', round((len(C)/float(len(U-C))), 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complement of A intersection C is {1, 2, 3, 4, 5, 6, 7, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}\n",
      "Odds of A intersection C are 0.3\n"
     ]
    }
   ],
   "source": [
    "print('Complement of A intersection C is', U-(A & C))\n",
    "P = (len(A & C)/float(len(U-(A & C))))\n",
    "print('Odds of A intersection C are', round(P, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conditional probability of A given C is 0.462\n"
     ]
    }
   ],
   "source": [
    "# Demonstrate conditional probability.\n",
    "P = round(len(A & C)/float(len(C)), 3)\n",
    "print('Conditional probability of A given C is', P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of A and C intersection is 0.231\n",
      "Probability of C is 0.5\n",
      "Product rule result for A and C intersection is 0.231\n"
     ]
    }
   ],
   "source": [
    "# Demonstrate the product rule.\n",
    "print('Probability of A and C intersection is', round((len(A & C)/T), 3))\n",
    "Q = len(C)/T\n",
    "print('Probability of C is', round(Q, 3))\n",
    "print('Product rule result for A and C intersection is', round(P*Q, 3))"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}