Introduction

Last day, we were showing the Perceptron update rule could be used to learn Nested Boolean Functions.
To do this we defined the notion of a gradual collection of hyperplanes, and used this to define the class of gradual boolean threshold functions.
We then showed that any nested boolean function can be represented as a gradual boolean threshold function.
I stated the theorem without proof that gradual boolean threshold functions are PAC-learnable using the perceptron update rule.
We then talked about where to find and download Python, and how to access the Python shell.
I have now added a proof to last days slides that gradual boolean threshold functions are PAC-learnable using the perceptron update rule.
To start today, we will go over this proof and then continue to discuss Python.

In-Class Exercise

Suppose we want to learn an `n`-bit nested boolean formula so that at least `1- 1/1000` of the time, the error rate was at most `1/(n+1)`. How many examples would the proof of the previous theorem suggest one should look at? Be specific on the value of `k` (look at our earlier proofs). Also, for what size `n` does this really make sense?

Post your solution to the Sep 13 In-Class Exercise Thread.

Python as Calculator; Programs in Files

You can use the command prompt as a quick calculator of python expressions. For example,
```
>>>2 / 3 + 7.9
```
outputs 7.9; whereas, 2.0/3 + 7.9 outputs 8.566666666666666.
You can refer to the last result by using an underscore similar to Perl. So after the last expression _ + 1 would give 9.566666666666666.
Python file are put into files with the .py extension. For example, we might have the file: hello.py with the following in it:
```
#!/usr/bin/env python
# The above would mean don't have to type python when run under *nix
# Comments begin with #
print "Hello World"
```
If we didn't have the first line or on Windows we would need to type "python hello.py" to run the program.

Variables and Arithmetic Expressions

Variables are bound to values by assignments. We don't have to declare variables before using them.

So we can do things like:

x = 7
x += 1 #note there are no ++ and -- operators
x *= 3
y = 5
z = x - y
print z

which would print 19

Notice we don't have to terminate statements with ';' although we can. If we want several statements of the same line we use ';'
Python supports a formatted string operator %:
```
print "%3d %0.2f" % (10, .9799)
```
prints 10 with a leading space followed by 0.98
There is also a format() function which outputs a string. So format(0.979, "0.2f") outputs the string 0.98 .

Conditionals

Python supports if elif else conditionals with the syntax:

a = 5
if a > 4:
    print "a is bigger than 4"

b = 99
if  b < 50:
    print "b is too little"
else:
    print "b is big enough"

if  a > 4 and  b < 50:
    print "1"
elif not a == 6:
    print "2"
else:
    print "3"

The bodies of these statements are denoted using indentation.
To create an empty clause, you can use the pass statement.
Python has boolean connectives and, or, and not.
Python uses the Boolean literal True and False.
Python does not have switch/case

File I/O

One could read in a file using a program like:

f = open("hello.py")
line = f.readline()
while line:
   print line, #comma omits print's newline char
   #print (line, end='') #in python 3
   line = f.readline()
f.close()

open() returns a file object
We can invoke methods of this object just as in Java (in this case, readline())
We could have also written:
```
for line in open("hello.py"):
    print line,
```
to achieve the same affect

To write a file we can do things like:

f = open("somefile.txt", "w")
print >>f, "%02f" %0.7999
f.write("hello")
f.close()

To get the command line arguments, get input from the terminal or write to the terminal we can use the sys.argv, sys.stdout and sys.stdin objects:

import sys

print "\n".join(sys.argv) # print the command line arguments, each on their own line
sys.stdout.write("Type something");
name = sys.stdin.readline()