
def showURL(url, ht=500):
    """Return an IFrame of the url to show in notebook with height ht"""
    from IPython.display import IFrame
    return IFrame(url, width='95%', height=ht) 
showURL('https://en.wikipedia.org/wiki/Function_(mathematics)#Introduction_and_examples',400)


showURL("https://en.wikipedia.org/wiki/Function_(mathematics)#Notation",300)


findFathersMap = {'Jenny': 'Jonathan', 'Cathy': 'Jonathan', 'Anu': 'Raaz', 'Ashu': 'Raaz'}
findFathersMap

{'Jenny': 'Jonathan', 'Cathy': 'Jonathan', 'Anu': 'Raaz', 'Ashu': 'Raaz'}


type(findFathersMap)     # find the type of findFathersMap

<class 'dict'>


findFathersMap['Anu']

'Raaz'


print("The father of Anu is", findFathersMap['Anu'])   # we can use a print statement to make it flow

The father of Anu is Raaz


findDaughtersMap = {'Jonathan': ['Jenny', 'Cathy'], 'Raaz': ['Anu', 'Ashu']}

# don't worry about the way we have done the printing below, just check the output makes sense to you!
for fatherKey in findDaughtersMap:
    print(fatherKey, "has daughters:")
    for child in findDaughtersMap[fatherKey]:
        print('\t',child)

Jonathan has daughters:
	 Jenny
	 Cathy
Raaz has daughters:
	 Anu
	 Ashu


myFunctionMap = {-2: 6, -1: 3,  0: 2, 1: 3, 2: 6}
myFunctionMap

{-2: 6, -1: 3, 0: 2, 1: 3, 2: 6}


myFunctionMap[-2]    # this return the value or image of the argument or key -2

6


myFunctionMap[-20] # the error message is clear, isn't it? "...KeyError: -20 since -20 is not in {-2,-1,0,1,2}"

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-10-dce75a49bb5d> in <module>()
----> 1 myFunctionMap[-Integer(20)] # KeyError: -20 since -20 is not in {-2,-1,0,1,2}

KeyError: -20


def myFunc(x):                                 # starting the definition
    '''A function to return x^2 + 2'''         # the docstring
    return x^2+2                               # the function body (only one line in this example


myFunc?


myFunc(0.1)   # use the function to calculate 0.1^2 + 2 with argument as a mpfr_real Literal

2.01000000000000


def myFunc(x):
    '''A function to return x^2 + 2'''
     return x^2+2


plot(myFunc(x),x, -20, 20)


?plot  # for help hit the DocString of the function


myPlot = plot(myFunc(x),x, -20, 20)
myPlot.show(figsize=[6,3])


type(myPlot)


myPlot.show?


# Don't worry about this code and just interact with its output cell by changing the value in the box labelled x
@interact
def _(my_x=input_box(3, width=10, label="$x$")):
    myPt = (my_x, myFunc(my_x))
    myLabel = "(%.1f, %.1f)" % myPt
    p = plot(myFunc, (x,-20,20))
    if (my_x >= -20 and my_x <= 20):
        p += point(myPt,rgbcolor='red', pointsize=20)
        p += text(myLabel, (my_x+4,myFunc(my_x)), rgbcolor='red')
    p.show(figsize=[6,3])


# plot 5 randomized points and leave them hanging
plot(myFunc,(-2,2), plot_points=5,marker='.',linestyle='', randomize=True, adaptive_recursion=0, figsize=[6,3])


# plot 5 randomized points and join them
plot(myFunc,(-2,2), plot_points=5,marker='.',linestyle='-', randomize=True, adaptive_recursion=0, figsize=[6,3])


# plot 100 randomized points and join them - now it looks continuous, doesn't it?
plot(myFunc,(-2,2), plot_points=100, marker='.',linestyle='-', randomize=True, adaptive_recursion=0, figsize=[6,3])


# plot 100 randomized points and join them without marker for points - now it looks like default plot, doesn't it?
plot(myFunc,(-2,2), plot_points=100, marker='',linestyle='-', randomize=True, adaptive_recursion=0, figsize=[6,3])


# Here is a quadratic function of x with three additional parameters a,b,c
def myQuadFunc(a,b,c,x):
    '''A function to return a*x^2 + b*x + c'''
    return a*x^2 + b*x + c


myQuadFunc(1, 0, 2, 10) # a = 1, b = 0, c = 2, x = 10


# we can make the same plot as before by letting a=1, b=0, c=2
plot(myQuadFunc(1,0,2,x),x, -20, 20, figsize=[6,3])


myFunc(float(0.1))   # use the function to calculate 0.1^2 + 2 with argument as a Python float

2.01


myFunc(1/10)         # use the function to calculate 0.1^2 + 2 with argument as a Sage Rational

201/100


myFunc(2)            # use the function to calculate 0.1^2 + 2 with argument as a Sage Integer

6


myFunc(int(2))       # use the function to calculate 0.1^2 + 2 with argument as a Sage Rational

6


myFunc('hello')      # calling myFunc on an input string argument results in a TypeError

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-18-57d5183bce47> in <module>()
----> 1 myFunc('hello')      # calling myFunc on an input string argument results in a TypeError

<ipython-input-11-303ff4c93b0f> in myFunc(x)
      1 def myFunc(x):                                 # starting the definition
      2     '''A function to return x^2 + 2'''         # the docstring
----> 3     return x**Integer(2)+Integer(2)                               # the function body (only one line in this example

/ext/sage/sage-9.1/local/lib/python3.7/site-packages/sage/rings/integer.pyx in sage.rings.integer.Integer.__pow__ (build/cythonized/sage/rings/integer.c:15017)()
   2224             return coercion_model.bin_op(left, right, operator.pow)
   2225         # left is a non-Element: do the powering with a Python int
-> 2226         return left ** int(right)
   2227 
   2228     cpdef _pow_(self, other):

TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'


'hello'*2  # or 'hello'*2 = 'hellohello', i.e., 'hello' concatenated with itself two times

'hellohello'


'hi'*3   # or 'hi'*3 = 'hihihi', i.e., 'hi' concatenated with itself three times

'hihihi'


'hello'+'hey'

'hellohey'


def myFunc2(x):
    '''square x and add x to it'''
    return x*2+x


myFunc2(0.1)

0.300000000000000


myFunc2('hi')             # 'hi'*2 + 'hi' = 'hihi'+'hi' = 'hihihi'

'hihihi'


cos(0)

1


sin(0)

0


sin(pi)

0


print('sin(pi) prints as', sin(pi))

sin(pi) prints as 0


# understand the output of each line and the symbolic/numeric expressions being evaluated and printed
print ('cos(1/2) prints as', cos(1/2))
print ('cos(1/2).n(digits=5) prints as', cos(1/2).n(digits=5))
print ('float(cos(1/2)) prints as', float(cos(1/2)))
print ('cos(0.5) prints as', cos(0.5))

print ('exp(2*pi*e) prints as', exp(2*pi*e))

print ('log(10) prints as', log(10))
print ('log(10).n(digits=5) prints as', log(10).n(digits=5))
print ('float(log(10)) prints as', float(log(10)))
print ('log(10.0) prints as', log(10.0))

cos(1/2) prints as cos(1/2)
cos(1/2).n(digits=5) prints as 0.87758
float(cos(1/2)) prints as 0.8775825618903728
cos(0.5) prints as 0.877582561890373
exp(2*pi*e) prints as e^(2*pi*e)
log(10) prints as log(10)
log(10).n(digits=5) prints as 2.3026
float(log(10)) prints as 2.302585092994046
log(10.0) prints as 2.30258509299405


x=-2


x.  # place the cursor after the . and press Tab


x.abs() #


abs(x)


?abs


L1 = []     # an empty list
L1          # display L1

[]


L2 = ['orange', 'apple', 'lemon']   # a list of strings - remember that strings are within quote marks
L2                                  # display L2

['orange', 'apple', 'lemon']


L2.append('banana')                 # append something to the end of a list
L2                                  # display L2

['orange', 'apple', 'lemon', 'banana']


L3 = [10, 11, 12 ,13]               # a list of integers


type(L3)                            # type of L3 is

<class 'list'>


len(L3)

4


L3[0]                               # the first position in the list is

10


L3[3]

13


L3[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-38-4884703f6616> in <module>()
----> 1 L3[Integer(4)]

IndexError: list index out of range


L3[0:2]                        # elements in positions 0 to 2 in list L3 are

[10, 11]


L4 = L3[:]
L4             # disclose L4

[10, 11, 12, 13]


L5 = range(10)                      # a quick way to make a list of 10 numbers starting from 0
L5

range(0, 10)


L6 = range(100, 150, 5)   # get a list with a specified start, stop and step 
L6

range(100, 150, 5)


?range


help(list.append)   # or use help for brief DocStrings


myList = [ REPLACE_THIS_WITH_ELEMENTS_OF_LIST ]


myNewList = myList[ REPLACE_THIS_WITH_THE_RIGHT_CHARACTER ]


len(myNewList)


myList[ FILL_IN_HERE ]


myNewList[0] = FILL_IN_HERE


print (myList)
print (myNewList)


rangeList = range( FILL_IN_HERE )


rangeList


myTuple1 = (1, 2) # assign the tuple (1,2) to variable nemed muTuple1
myTuple1

(1, 2)


type(myTuple1)

<class 'tuple'>


myTuple2 = (10, 11, 13)
myTuple2

(10, 11, 13)


myTuple1[0] # disclose what is in the first position in the tuple

1


myTuple1[0] = 10     # try to assign a different value to the first position in the tuple

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-49-1518de252015> in <module>()
----> 1 myTuple1[Integer(0)] = Integer(10)     # try to assign a different value to the first position in the tuple

TypeError: 'tuple' object does not support item assignment


myTuple1[0]    # the first element in the tuple is immutably 1

1


zip(['x', 'y', 'z'], [1, 2, 3])

<zip object at 0x7f73e22d8648>


L6 = range(100, 150, 5)  # make sure we have a list L6
S = set(L6)     # make the set S from the list L6
S             # display the set s

{100, 105, 110, 115, 120, 125, 130, 135, 140, 145}


S[0] # will give an error message 'TypeError: 'set' object does not support indexing'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-53-1fd82c49af26> in <module>()
----> 1 S[Integer(0)] # will give an error message 'TypeError: 'set' object does not support indexing'

TypeError: 'set' object is not subscriptable


S. # put the cursor after the . and hit Tab to see all the methods available on Python set


SS = Set(L6) # this is a SageMath set with upper-case Set


SS. # put the cursor after the . and hit Tab to see all the extra methods available on SageMath Set


findFathersMap = {'Jenny': 'Jonathan', 'Cathy': 'Jonathan', 'Anu': 'Raaz', 'Ashu': 'Raaz'}
findFathersMap

{'Jenny': 'Jonathan', 'Cathy': 'Jonathan', 'Anu': 'Raaz', 'Ashu': 'Raaz'}


type(findFathersMap)

<class 'dict'>


findFathersMap['Anu']           # who is Anu's father

'Raaz'


myPhoneDict = {'Ben': 8888, 'Raaz': 3333}
myPhoneDict     # disclose the contents of the dictionary

{'Ben': 8888, 'Raaz': 3333}


myPhoneDict['susy']=78987


myPhoneDict           # disclose the current contents of our dict

{'Ben': 8888, 'Raaz': 3333, 'susy': 78987}


myKeys = ('Ben', 'Raaz', 'susy')
myValues = (888, 333, 78987)
myPhoneDictByZip = dict(zip(myKeys, myValues))
myPhoneDictByZip

{'Ben': 888, 'Raaz': 333, 'susy': 78987}


myPhoneDictByZip['Fred']=1234
myPhoneDictByZip['Mary']=7777


myPhoneDictByZip

{'Ben': 888, 'Raaz': 333, 'susy': 78987, 'Fred': 1234, 'Mary': 7777}


myPhoneDictByZip['Ben']

888


myPhoneDictByZip.keys()

dict_keys(['Ben', 'Raaz', 'susy', 'Fred', 'Mary'])


myPhoneDictByZip.values()


myPhoneDictByZip.items()

dict_items([('Ben', 888), ('Raaz', 333), ('susy', 78987), ('Fred', 1234), ('Mary', 7777)])


showURL("https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model",400)


# create a class for a probability map - if you are new to SageMath/Python just evaluate and skip this cell
# This was coded by Jenny Harlow

import copy
class ProbyMap(object):                # class definition
    'Probability map class'
    def __init__(self, sspace, probs): # constructor
        self.__probmap = {}  # default probmap is empty
        # make checks on the objects given as sspace and probs
        try:                           
            sspace_set = set(sspace) # check that we can make the sample space into a set
            assert len(sspace_set) == len(sspace) # and not lose any elements
            prob_list = list(probs) # and we can make the probs into a list
            probsum = sum(prob_list) # and we can sum the probs
            assert probsum == 1 # and the probs sum to 1
            assert len(prob_list) == len(sspace_set) # and there is proby for each event
            
            self.__probmap = dict(zip(list(sspace),prob_list))    # map from sspace to probs
                    
        except TypeError as diag: # if there any problems with types
            init_error = 1
            print (str(diag))
            
        except AssertionError as e:
            init_error = 1
            print ("Check sample space and probabilities")
            
                  
    def P(self, events):
        '''Return the probability of an event or set of events.
        
        events is set of events in the sample space to calculate the probability for.'''
        
        retvalue = 0
        try:                              
            events_set = set(events) # check we can make a set out of the events
            assert len(events_set) == len(events) # and not lose any events
            assert events_set <= set(self.__probmap.keys()) # events subset of sample space
        
            for ev in events:     # add each mapped probability to the return value
                retvalue += self.__probmap[ev]
                
        except TypeError as diag:
            print (str(diag))      
        
        except AssertionError:
            print ("Check your events")
        
        return retvalue
        
    def __str__(self):                            # redefine printable string rep
        'Printable representation of the object.'
        num_keys = len(self.__probmap.keys())
        counter = 0
        retval = '{'
        for each_key in self.__probmap:
            counter += 1
            retval += str(each_key)
            retval += ': '
            retval += "%.3f" % self.__probmap[each_key]
            if counter < num_keys:
                retval += ', '
        retval += '}'        
                
        return retval
        
    __repr__ = __str__
        
    def get_probmap(self):                        # get a deep copy of the proby map
        return copy.deepcopy(self.__probmap)      # getter cannot alter object's map
    
    probmap = property(get_probmap)               # allow read access via .probmap
    
    def get_ref_probmap(self):                    # get a reference to the real probmap
        return self.__probmap                     # getter can alter the object's map
        
    
    ref_probmap = property(get_ref_probmap)       # allow access via .ref_probmap
    
    @staticmethod
    def dictExp(big_map, small_map):
        '''Internal helper function for __pow__(...).
        
        Takes two proby map dictionaries and returns one mult by other.'''
        new_bl = {}
        for sle in small_map:
            for ble in big_map:
                new_key = str(ble) + ' ' + str (sle)
                new_bl[new_key] = big_map[ble]*small_map[sle]
        return new_bl
        
    def __pow__(self, x):
        '''probability map exponentiated.'''
        try:
            assert isinstance(x, Integer)
            pmap = copy.deepcopy(self.__probmap) # copy the probability map dictionary
            new_pmap = copy.deepcopy(self.__probmap) # and another copy
            for i in range(x-1):
                new_pmap = self.dictExp(new_pmap, pmap)
            
            return ProbyMap(new_pmap.keys(), new_pmap.values())       
            
        except AssertionError as e:
            print ("cannot raise to non-integer power")
            return None


# sample space is the set of distinct type of fruits in the bowl
samplespace = ['orange', 'apple', 'lemon']


# probabilities take into account the number of each type of fruit in the "well-stirred" fruit bowl
probabilities = [2/6, 3/6, 1/6]


probMapFruitbowl = ProbyMap(sspace = samplespace, probs=probabilities) # make our probability map
probMapFruitbowl         # disclose our probability map

{orange: 0.333, apple: 0.500, lemon: 0.167}


# Find the probability of outcome 'lemon'
probMapFruitbowl.P(['lemon'])

1/6


# Find the probability of the event {lemon, orange}
probMapFruitbowl.P(['lemon','orange'])

1/2


# make the set of all possible events from the set of outcomes 
setOfAllEvents = Subsets(samplespace)  # Subsets(A) returns the set of all subsets of A
list(setOfAllEvents)    # disclose the set of all events

[{},
 {'orange'},
 {'apple'},
 {'lemon'},
 {'apple', 'orange'},
 {'lemon', 'orange'},
 {'apple', 'lemon'},
 {'apple', 'lemon', 'orange'}]


# loop through the set of all events and print the computed probability
for event in setOfAllEvents:
    print ("P(", event, ") = ", probMapFruitbowl.P(event))

P( {} ) =  0
P( {'orange'} ) =  1/3
P( {'apple'} ) =  1/2
P( {'lemon'} ) =  1/6
P( {'apple', 'orange'} ) =  5/6
P( {'lemon', 'orange'} ) =  1/2
P( {'apple', 'lemon'} ) =  2/3
P( {'apple', 'lemon', 'orange'} ) =  1


alphaspace = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
              'R','S','T','U','V','W','X','Y','Z']
alphaRelFreqs = [73/1000,9/1000,30/1000,44/1000,130/1000,28/1000,16/1000,35/1000,74/1000,
                 2/1000,3/1000,35/1000, 25/1000,78/1000,74/1000,27/1000,3/1000,77/1000,63/1000,
                 93/1000,27/1000,13/1000,16/1000,5/1000,19/1000,1/1000]


probMapLetters = ProbyMap(sspace = alphaspace, probs=alphaRelFreqs) # make our probability map
probMapLetters         # disclose our probability map

{A: 0.073, B: 0.009, C: 0.030, D: 0.044, E: 0.130, F: 0.028, G: 0.016, H: 0.035, I: 0.074, J: 0.002, K: 0.003, L: 0.035, M: 0.025, N: 0.078, O: 0.074, P: 0.027, Q: 0.003, R: 0.077, S: 0.063, T: 0.093, U: 0.027, V: 0.013, W: 0.016, X: 0.005, Y: 0.019, Z: 0.001}


2^26

67108864


vowels = ['A', 'E', 'I', 'O', 'U']


probMapLetters.P(vowels)

189/500


NameOfRaaz=set("RAAZESHSAINUDIIN")        # make a set from a string
NameOfRaaz                                # disclose the set NameOfRaaz you have built

{'A', 'D', 'E', 'H', 'I', 'N', 'R', 'S', 'U', 'Z'}


probMapLetters.P(NameOfRaaz)

301/500

E	13.0%	H	3.5%	W	1.6%
T	9.3%	L	3.5%	V	1.3%
N	7.8%	C	3.0%	B	0.9%
R	7.7%	F	2.8%	X	0.5%
O	7.4%	P	2.7%	K	0.3%
I	7.4%	U	2.7%	Q	0.3%
A	7.3%	M	2.5%	J	0.2%
S	6.3%	Y	1.9%	Z	0.1%
D	4.4%	G	1.6%

Introduction to Data Science: A Comp-Math-Stat Approach¶

1MS041, 2021¶

03. Map, Function, Collection, and Probability¶

Maps and Functions¶

Mathematical notation for functions¶

Example 1: Encoding a function or map as a set of ordered pairs¶

Example 2: Encoding function as a procedure¶

The basics steps in encoding a function as a procedure in SageMath/Python:¶

YouTry¶

A bit under plot's hood¶

You try¶

Example 3: Polymorphism and Type Errors¶

Example 4: Mathematical functions¶

You try¶

Collections in Sage¶

Example 1: Lists¶

YouTry¶

Start of this YouTry¶

END of YouTry¶

Example 2: Tuples¶

Useful things you can do with tuples¶

Example 3: Sets¶

Example 4: Dictionaries¶

Manipulating a dict¶

You try¶

Probability¶

Roll a dice experiment¶

Flip a coin experiment¶

Draw a fruit from a fruit bowl¶

Example 1: Tossing a fair coin¶

Example 2: Tossing an unfair coin¶

Example 2': Tossing an unfair coin $m$ times to construct a random graph¶

Draw the construction on a graph with $n$ vertices and $m$ edges.¶

Example 3: New Zealand Lotto¶

Property 1¶

Property 2¶

Computer Representations of Mathematical Concepts and Objects¶

Example 4: Experiments, outcomes, sample spaces, events, and the probability of events¶

YouTry¶

Example 5: Experiments with the English language¶

Example oo - A Double Pendulum Experiment¶

A Coming Attraction!¶

Introduction to Data Science: A Comp-Math-Stat Approach ¶