Lesson 02 Set operations using sympy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sympy as sym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sym.init_printing(use_latex = \"mathjax\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set operations using *sympy*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this lesson"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Follow these links\n",
    "- [Introduction](#Introduction)\n",
    "- [The union of sets](#The-union-of-sets)\n",
    "- [The intersection of sets](#The-intersection-of-sets)\n",
    "- [The difference between sets](#The-difference-between-sets)\n",
    "- [The symmetric difference](#The-symmetric-difference)\n",
    "- [The complement of a set](#The-complement-of-a-set)\n",
    "    - [Laws of complements](#Laws-of-complements)\n",
    "- [Laws of set operations](#Laws-of-set-operations)\n",
    "- [Duality](#Duality)\n",
    "- [The counting principle](#The-counting-principle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before we will start with a defined universal set, $ U $.  We then take an arbitrary number of sets $ A, B, C, \\dots $ such that the elements of these sets are all taken from $ U $ and they each consist of a finite set of elements that are countable.<p/>\n",
    "In this lesson we will perform operations on these sets, causing some interaction between them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The union of sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use *sympy* (short for symbolic python) as a computer algebra system to demonstrate many of the set operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Creating symbols (mathematical constants that act as elements)\n",
    "a, b, c, d, e, f, g, h = sym.symbols(\"a, b, c, d, e, f, g, h\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Creating two finite sets\n",
    "A = sym.FiniteSet(a, b, c, d)\n",
    "B = sym.FiniteSet(e, f, g, h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, d\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, d}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the set to the screen\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{e, f, g, h\\right\\}$$"
      ],
      "text/plain": [
       "{e, f, g, h}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the set to the screen\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking to see if the set is indeed finite\n",
    "A.is_FiniteSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ask *sympy* to check if a value is an element of a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the symbol g in the set A?\n",
    "g in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the symbol a in the set A?\n",
    "a in A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **union** combines the elements of sets.  Let's ask *sympy* to caluclate the union of sets $ A $ and $ B $, written as $ A \\cup B$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, d, e, f, g, h\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, d, e, f, g, h}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Union(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have to deal with repetitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, e\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, e}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a finite set with repeated elements\n",
    "C = sym.FiniteSet(a, a, b, b, b, c, e, e, e)\n",
    "\n",
    "# Print it to the screen\n",
    "C # Repeat elemenst will be omitted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{d, e, f\\right\\}$$"
      ],
      "text/plain": [
       "{d, e, f}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a finite set with repeated elements\n",
    "D = sym.FiniteSet(e, e, f, d)\n",
    "\n",
    "# Print it to the screen\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, d, e, f\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, d, e, f}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All repeated elements are removed from the union as well\n",
    "sym.Union(C, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Sympy* can also deal with intervals.  Intervals in this setting are simply sets.  They have a start and end value and each can be specified as open or close.  Let's create some intervals and calculate their unions.  The first interval shoudl be of this form $$ \\left\\{ x \\quad | \\quad -3 \\le x < 4 \\right\\} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[-3, 4\\right)$$"
      ],
      "text/plain": [
       "[-3, 4)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an interval which is closed on the left and open on the right\n",
    "# Syntax: sympy.Interval(start value, end value, left_open state, right_open state)\n",
    "# The default state is close\n",
    "A = sym.Interval(-3, 4, left_open = False, right_open = True)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(4, 7\\right]$$"
      ],
      "text/plain": [
       "(4, 7]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = sym.Interval(4, 7, left_open = True, right_open = False)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[-3, 4\\right) \\cup \\left(4, 7\\right]$$"
      ],
      "text/plain": [
       "[-3, 4) ∪ (4, 7]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Union(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that $ 4 $ is not included in this union."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 in sym.Union(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking a little tangent just to look at these intervals a little closer, note the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$-3$$"
      ],
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The first element in the interval A\n",
    "A.start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$4$$"
      ],
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The last element in the interval A\n",
    "A.end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\mathrm{False}$$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the left-side of the interval open?\n",
    "A.left_open"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\mathrm{True}$$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the right-side of the interval open?\n",
    "A.right_open"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An unbounded interval has as its boundaries either negative of positive infinity, $ \\pm \\infty $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the left-side of the interval A unbounded?\n",
    "A.is_left_unbounded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the right-side of the interval A unbounded?\n",
    "A.is_right_unbounded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a right-sided unbounded interval using the *sympy* infinity symbol, ```sympy.oo```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[0, \\infty\\right)$$"
      ],
      "text/plain": [
       "[0, ∞)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O = sym.Interval(0, sym.oo)\n",
    "O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O.is_right_unbounded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to unions.  There is an alternative syntax for unions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[-3, 4\\right) \\cup \\left(4, 7\\right]$$"
      ],
      "text/plain": [
       "[-3, 4) ∪ (4, 7]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The intersection of sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **intersection** operation looks for elements that appear in both sets (all sets of there are more than two).  For two sets we denote this as $ A \\cap B $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Creating two finite sets\n",
    "A = sym.FiniteSet(a, b, c, d)\n",
    "B = sym.FiniteSet(e, f, g, h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\emptyset$$"
      ],
      "text/plain": [
       "∅"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Intersection(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the sets $ A $ and $ B $ above have no elements in common, the intersection operation returns the empty set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a finite set with repeated elements\n",
    "C = sym.FiniteSet(a, a, b, b, b, c, e, e, e)\n",
    "\n",
    "# Create a finite set with repeated elements\n",
    "D = sym.FiniteSet(e, e, f, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{e\\right\\}$$"
      ],
      "text/plain": [
       "{e}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Intersection(C, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as with unions, there is an alernative syntax for intersections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{e\\right\\}$$"
      ],
      "text/plain": [
       "{e}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.intersection(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The difference between sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **difference between sets** is also called the **relative complement of one set with respect to another**.  Here we subtract the elements of the second set from those in the first.  If their intersection is the empty set then we simply end up with the first set as is.  Mathematically we will have $$ \\left\\{ x \\in U \\quad | \\quad x \\in A, \\quad x \\notin B \\right\\} $$ written as $$ A - B $$ or $$ A \\setminus B $$ or $$ A \\sim B $$ or even $$ A - \\left( A \\cap B \\right) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, d\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, d}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A - B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since $ A $ and $ B $ have no elements in common, there are no elemnts to remove from $ A $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check to see if $ A - B $ is the same as $ A - \\left( A \\cap B \\right) $.  To do this we can use the double equal sign, ```==```, that will return a value of ```True``` if the left and right-hand sides as equal and a ```False``` if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A - B) == (A - sym.Intersection(A, B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets $ C $ and $ D $ have the element $ \\left\\{ e \\right\\} $ in common.  This will be removed from $ C $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C - D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The symmetric difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **symmetric difference** is denoted as such $$ \\left\\{ x \\in U \\quad | \\quad x \\in A \\cup B, \\quad x \\notin A \\cap B \\right\\} $$\n",
    "written as $$ A \\oplus B $$\n",
    "This means that we first take the union of the two sets and then subtract the elements that are in their intersection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left ( \\left\\{a, b, c, d, e, f\\right\\}, \\quad \\left\\{e\\right\\}, \\quad \\left\\{a, b, c, d, f\\right\\}\\right )$$"
      ],
      "text/plain": [
       "({a, b, c, d, e, f}, {e}, {a, b, c, d, f})"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the union, intersection and symmetric intersection to the screen\n",
    "sym.Union(C, D), sym.Intersection(C, D), sym.Union(C, D) - sym.Intersection(C, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we could also write the symmetric difference as $$ \\left( A - B \\right) \\cup \\left( B - A \\right) $$ or $$ \\left( A \\cup B \\right) - \\left( A \\cap B \\right) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{a, b, c, d, f\\right\\}$$"
      ],
      "text/plain": [
       "{a, b, c, d, f}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Union((C - D), (D - C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The complement of a set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **absolute complement of a set** is the difference netween the universal set which the set was taken from and the set itself.  We write $$ {A}^{c} = \\left\\{ x \\quad | \\quad x \\in U, \\quad x \\notin A \\right\\} $$\n",
    "It is also written as $ A' $ or $ \\overline{A} $.\n",
    "We stress the term absolute complement, because, although we usually do refer to the above simply as the complement, there is indeed a **relative complement** which is just the difference between sets as we saw above ([The difference between sets](#The-difference-between-sets))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left ( \\left\\{1, 2, 3, 4, 5, 6, 7, 8, 9\\right\\}, \\quad \\left\\{3, 5, 7\\right\\}\\right )$$"
      ],
      "text/plain": [
       "({1, 2, 3, 4, 5, 6, 7, 8, 9}, {3, 5, 7})"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating two finite sets\n",
    "U = sym.FiniteSet(1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
    "A = sym.FiniteSet(3, 5, 7)\n",
    "\n",
    "# Printing both to the screen\n",
    "U, A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Setting U as a universal set\n",
    "U.is_UniversalSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 4, 6, 8, 9\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 4, 6, 8, 9}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the complement of A (with respect to U)\n",
    "A.complement(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Sympy* contains the singleton called ```S```.  We can represent it as a universal set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.singleton.SingletonRegistry"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sym.S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can have a look at the complement of $ A $ with respect to this universal set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$UniversalSet() \\setminus \\left\\{3, 5, 7\\right\\}$$"
      ],
      "text/plain": [
       "UniversalSet() \\ {3, 5, 7}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.complement(sym.S.UniversalSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a little tangent again, we have another representation of the singleton ```S``` and that is the empty set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\emptyset$$"
      ],
      "text/plain": [
       "∅"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.S.EmptySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 3, 4, 5, 6, 7, 8, 9\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The complement of the empty set with respect to the universal set is the universal set\n",
    "U - sym.S.EmptySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$UniversalSet() \\setminus \\emptyset$$"
      ],
      "text/plain": [
       "UniversalSet() \\ ∅"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another syntax\n",
    "sym.S.EmptySet.complement(sym.S.UniversalSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we are on this tangent, let's look at some other special representations of the singleton ```S```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we have the natural numbers, $ \\mathbb{N} = \\left\\{ 1, 2, 3, 4, 5, \\dots \\right\\} $. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is 1 a natural number?\n",
    "1 in sym.S.Naturals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is -1 a natural number?\n",
    "-1 in sym.S.Naturals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is 0 a natural number?\n",
    "0 in sym.S.Naturals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we have the counting numbers, $ \\left\\{ 0, 1, 2, 3, 4, 5, \\dots \\right\\} $.  The counting numbers are represented in *sympy* as ```sympy.S.Naturals0```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is 0 a natural number?\n",
    "0 in sym.S.Naturals0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The integers, $ \\mathbb{Z} $, are represented by ```sympy.S.Integers```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is one-half an integer?\n",
    "1 / 2 in sym.S.Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have the real numbers, $ \\mathbb{R} $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\mathbb{R}$$"
      ],
      "text/plain": [
       "ℝ"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.S.Reals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, a lot of fun.  Just type ```sym.S.``` and hit the TAB key to see all the singletons.  Alright, just a few more!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are the integers a proper superset of the real numbers\n",
    "sym.S.Integers.is_proper_superset(sym.S.Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are the integers a superset of the real numbers\n",
    "sym.S.Integers.is_superset(sym.S.Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are the integers a proper subset of the real numbers\n",
    "sym.S.Integers.is_proper_subset(sym.S.Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are the integers a subset of the real numbers\n",
    "sym.S.Integers.is_subset(sym.S.Reals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Laws of complements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few laws associated with complements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first states that $ {\\left( {A}^{c} \\right)}^{c} = A $.  This is the **involution law**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next up are **De Morgan's laws** $$ { \\left( A\\cup B \\right)  }^{ c }={ A }^{ c }\\cap { B }^{ c }\\\\ { \\left( A\\cap B \\right)  }^{ c }={ A }^{ c }\\cup { B }^{ c } $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see these as an example for $$ U = \\left\\{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 \\right\\} \\\\ A = \\left\\{ 1, 2, 3, 4, 5, \\right\\} \\\\ B = \\left\\{ 3, 4, 5, 6, 7 \\right\\} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U = sym.FiniteSet(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "U.is_UniversalSet\n",
    "U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 3, 4, 5\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = sym.FiniteSet(1, 2, 3, 4, 5)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{3, 4, 5, 6, 7\\right\\}$$"
      ],
      "text/plain": [
       "{3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = sym.FiniteSet(3, 4, 5, 6, 7)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{8, 9, 10\\right\\}$$"
      ],
      "text/plain": [
       "{8, 9, 10}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Union(A, B).complement(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{8, 9, 10\\right\\}$$"
      ],
      "text/plain": [
       "{8, 9, 10}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Intersection(A.complement(U), B.complement(U))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Question\n",
    "sym.Union(A, B).complement(U) == sym.Intersection(A.complement(U), B.complement(U))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 6, 7, 8, 9, 10\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Intersection(A, B).complement(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left\\{1, 2, 6, 7, 8, 9, 10\\right\\}$$"
      ],
      "text/plain": [
       "{1, 2, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Union(A.complement(U), B.complement(U))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sym.Intersection(A, B).complement(U) == sym.Union(A.complement(U), B.complement(U))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The proof of De Morgan's Laws are easy.  For the first it will be $$ { \\left( A\\cup B \\right)  }^{ c }={ A }^{ c }\\cap { B }^{ c }\\\\ \\therefore \\quad x\\in { \\left( A\\cup B \\right)  }^{ c }\\Rightarrow x\\notin \\left( A\\cup B \\right) \\\\ \\therefore \\quad x\\notin A,x\\notin B\\\\ \\therefore \\quad x\\in { A }^{ C },x\\in { B }^{ C }\\\\ \\therefore \\quad { \\left( A\\cup B \\right)  }^{ c }={ A }^{ c }\\cap { B }^{ c } $$\n",
    "For an element to be in one set **and** in another, it must be in their intersection, $ \\therefore \\quad x\\in { A }^{ C },x\\in { B }^{ C } = { A }^{ c }\\cap { B }^{ c } $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other laws of complements are\n",
    "- $ A \\cup {A}^{c} = U $\n",
    "- $ {U}^{c} = \\emptyset $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laws of set operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Indempotent laws** $ A \\cup A = A $ and $ A \\cap A = A $\n",
    "- **Associative laws** $ \\left( A \\cup B  \\right) \\cup C = A \\cup \\left( B \\cup C \\right) $ and $ \\left( A \\cap B  \\right) \\cap C = A \\cap \\left( B \\cap C \\right) $\n",
    "- **Commutative laws** $ A \\cup B = B \\cup A $ and $ A \\cap B = B \\cap A  $\n",
    "- **Distributive laws** $ A \\cup \\left( B \\cap C \\right) = \\left( A \\cup B \\right) \\cap \\left( A \\cup C \\right) $ and $ A \\cap \\left( B \\cup C \\right) = \\left( A \\cap B \\right) \\cup \\left( A \\cap C \\right) $\n",
    "- ** Identity laws** $ A \\cup \\emptyset = A $ and $ A \\cup U = U $ and $ A \\cap U = A $ and $ A \\cap \\emptyset = \\emptyset $\n",
    "- **Absorption laws** $ A \\cup \\left( A \\cap B \\right) = A $ and $ A \\cap \\left( A \\cup B \\right) = A $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Duality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might have noted that the laws above come in pairs.  If we defeine one of each pair as an equation of set algebra and called it $ E $, the we can create $ {E}^{*} $ by interchanging $ \\cup, \\cap, \\mathbb{U}, \\emptyset $ for $ \\cap, \\cup, \\emptyset, \\mathbb{U} $ respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called the **principle of duality** and is states that if any equation $ E $ is an idenity, then its dual, $ {E}^{*} $ is also an identity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The counting principle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **modulus** is the number of elements in a set as is denoted by $ \\left| S \\right| $ or $ n \\left( S \\right) $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can classify any set, $ S $, as a **finite** set if it is either the empty set, $ \\emptyset $, or its modulus is equal to $ n $, where $ n \\in \\mathbb{N} $.  If neither of these two conditions are met, the set is **infinite**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The set of all integers, $ \\mathbb{Z} $, is infinite and so is the set $ \\left\\{ x \\quad | \\quad 0 \\le x \\le 1, \\quad x \\in \\mathbb{R} \\right\\} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Infinite sets can be **countably infinite**.  This occurs when the elements of the set can be arranged as a **sequence**.  Otherwise, it is simply **uncountable**.  A finite set is countable.<p/>\n",
    "The set $ \\left\\{ x \\quad |  \\quad x \\in \\mathbb{Z} \\right\\} $ is thus countably infinite, whereas the set $ \\left\\{ x \\quad | \\quad 0 \\le x \\le 1, \\quad x \\in \\mathbb{R} \\right\\} $ is uncountable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lesson)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}