http://feeds.delicious.com/v2/rss/jfredett/gradschool

It’s an RSS feed, but also the only sane url-link to the specific tag. It’s just my del.icio.us space under the tag “gradschool”

Heres my situation, I transferred last year from one school (WPI) to another, cheaper school (WSC)[1]. In doing so, two things happened.

1. I had to redo a fair deal of work. Many credits didn’t transfer, weren’t applicable, or became electives due to requirement differences
2. I suffered a bit of a blow to my now fragile GPA, I’ve had 10 classes so far, and due to the rapid change of material and teaching style, as well as the new stresses and frustrations of repeating much of what I already knew, or taking classes I had no interest in, I did not do very well in most of them. My GPA is a pitiful 2.6… (I got a fuckload of C’s.)

Now, fortunately, I have good grades in my Core courses, most of the outliers (Philosophy excepted, I am stunningly good at that, it seems) are the ones that caused the brunt of the average-destruction. My hope is to pull these grades up with all my vigor. I have calculated that — in the 10-12 classes I have left, I need to get consisent B’s and B+’s to recover to a “safe” 3.2 or so (what I had when I left WPI). The various websites I’ve read say that this is a good average, and combined with me doing un-fucking-believable on the GRE’s, I should be able to get into a decent grad school.

I’ll try to keep Lowlymath.net[2] updated with my adventures in grad school application, and hopefully it will be a resource to anyone else hunting for graduate education.

No little thing like a bad GPA will keep me down, if necessary, I’ll take every math class WSC, WPI, and the rest of the consortium[3] offers to pull up my grade! Someday you’ll all be able to say “Whatsup Doc?” to me, and I will be quite pleased about it!

/Joe

[1] Thats Worcester Polytechnical Institute and Worcester State College, respectively.

[2] I’m actually posting to both blogs at once right now, so the Lowlymath Readers can just mentally replace “Lowlymath.net” with “this blog”

[3] The Consortium is a group of 6 schools which allow for “easy” crossregistration of classes and (supposedly) “easy” transfers between institutions. Though the latter is somewhat of a misrepresentation, given my experience.

Everyone should watch this show, Hold off on buying episodes till they air a few more, but I guarantee, if this is going to be the road the show takes, I’ll be buying a full season.

Fan-frigging-tastic.

On another note, hopefully I’ll start being able to do some more blogging, I’ve been working on some videos, I’ve put a few up on the tubes. In any case, check it out, subscribe if you like, hopefully I’ll be internet-famous someday, like thunderfoot or edwardcurrent.

Oh, one more tube related thing. In case you people feel that I hate all religious people, you should check out DonExodus2 on the tubes, he’s a PhD biologist, anticreationist christian.

If all Christians were like DonExodus, I would be out of a job.

Here’s the solution from last time.

Recall that the problem was to determine what score you would need on the new SATs to match your older brothers score of 1460 on the old SATs.

The first step is to realize that the old score is really 1460 out of 1600, or 1460/1600 = 146/160 = 73/80. We’ll call that number B, for “Brothers score.” Next, we need to realize that your score will be something out of 2400, we can write that as m = x/2400. The next step is to convert B to a percentage, and then we have the problem in a form we know, that of a “x percent of y” problem. Using the definition, we find that 73/80 is 91.25% of 80. So now we want to find 91.25% of 2400, using a calculator we find that this is: 2190.0 even, so you’d need to score 2190 to match your older brothers score.

So what is algebra? Most people would answer, “That math with the letters in it.” But really, this is just what algebra looks like. Really, Algebra is about equalities, and specificly about equalities involving unknown numbers. To understand equalities, we need to name the two types, what I call “resolved equalities”, eg:

“x = 2″, “y = z”, or “x = 3/4 + 1″.

and “unresolved equalities”, eg:

“(x + y)*(x - y) = 2″ or “x^2 + 2 = 4″

The basic idea is that, when you read the equality, if it looks like “<some letter> = <any old expression>” then it’s a resolved equality.

The neat thing about equalities is that you can substitute with them, in math, this is called the transitive property, it just means that if I know: “x = y” and “y = z”, then I can substitute ‘z’ for ‘y’ to get “x = z”. Simple enough.

The other idea that gives rise to algebra is the idea of unknowns, we’ve used them a bit already, but let me explain the motivation for them a little more.

When you do normal arithmetic, you typically do problems like “12 x 23 = something”, or “12 + 23 = something”, or some combination of these. These things are really algebraic expressions, in the language of algebra, we’d write them as “x = 12*23″ or “x = 12 + 23″, when we do arithmetic we’re really solving resolved equalities in algebra. So then, algebra is the next logical jump, it’s a set of rules for solving unresolved equalities.

So, how do we come up with rules to do that? Really, it only requires one rule, we’ll call it the “fairness” rule, specificly it says that, given any equality, we can take some operation and do it to both sides, and get an equality back. Later we’ll learn how to write this in symbols, but for now, we’ll just remember it as the following adage, “Anything you do to one side, you have to do to the other.” This rule, along with the transitivity rule, allows us to transform just about any unresolved equality into a resolved one. Pretty powerful stuff.

So lets do a couple of problems with unresolved equalities, solve for x in the following:

• “3x = 9″
• “3x - 1 + y = 2x + y”
• “3x^2 = 27″

The first one is pretty easy, we just need to find an operation to get rid of the 3 on the left side, the obvious choice is to divide by three on both sides, and in fact, thats the right choice. Doing so, we get “3x/3 = 9/3.” So now how do we simplify that to get a resolved equality? Well, realize that saying “3x” is just saying that you have a number with a factor of three in it, a factor which you can remove by dividing, and in general saying “n*x” is the same as saying that you have a number with a factor of n in it. So what do you have left from a multiple of three when you divide by three? Simply, “x” — the other factor of the equation. So our answer is then “x = 9/3″, or more simply “x = 3″. That was easy.

What we did with multiplication, also works with addition, or any other operation. So lets try it out on the second equation. We won’t do as much explaining, I’m just going to list the steps:

1. 3x - 1 + y = 2x + y
2. 3x - 1 + y - y = 2x + y - y
3. 3x - 1 = 2x
4. 3x - 2x - 1 = 2x - 2x
5. x - 1 = 0
6. x - 1 + 1 = 0 + 1
7. x = 1

The important things to note here are in steps 4 and 5. In step 4, we’re subtracting a multiple of an unknown from a multiple of an unknown, this implicitly[1] uses a notion called “factoring,” which you may have heard of in arithmetic, where you would factor numbers into individual components. Here, it means the following, If you have something like: k*x + n*x, then you can write it as x * (k + n). This is because when we expand multiplication on an expression in parenthesis, we multiply the expression on the outside of the parenthesis with each item in the parenthesis. We can see this with numbers by looking at the following example:

• x = 9 + 27
• x = (3*3) + (3*9)
• x = 3(3 + 9) — you see how we removed the common factor of three, and now we have two simpler problems
• x = 3*12
• x = 36

The other step I noted, step 5, underlies a really important thing in algebra, the existence of the number zero, and specifically, the fact that you can have expressions equal to it. This comes up when dealing with quadratic equations (we’ll talk about those later), Calculus, and virtually all of the rest of mathematics.

The third equation I listed is solved as follows:

1. 3x^2 = 27
2. 3x^2 / 3 = 27/3
3. x^2 = 9
4. sqrt(x^2) = sqrt(9)
5. x = +3 or -3

The important, and possibly confusing step here is step 5, after taking the square root (written as sqrt(x^2) here) — the inverse operation of x^2, which means “x multiplied by itself twice”, and in general x^n means “x times itself n times” — I wrote that x is equal to either +3 or -3. It’s easy to see if we plug either answer in to the equation in step 3, both +3*+3 = 9, and (-3) * (-3) = 9. [2]

So, with what I’ve armed you with so far, you should be able to master a few more problems, since algebra is such a big subject, I can’t teach it in just one post, so this is as far as we’ll go this time, I’ll leave a few more algebra problems for you to try out. It’ll work like this, I’ll give you the original unresolved equality, and a variable to solve for, and your job is to find the list of manipulations, one at a time, to go from the unresolved equality to a resolved equality. Here they are.

In all three, solve for x, they rank from easiest to hardest:

1. 8x + 1 = 17
2. 2(9x + 4y) = (18 + 16y)/2
3. 10x^2 + 6 = 1006

[1] In case you haven’t seen that term before, it means that we’re using some rule without explicitly stating it.

[2] It may seem counterintuitive now, but you’ll have to take my word on it, a negative times a negative is a positive. We’ll get to this idea later.

This is a nice little code dump I was trying to have posted yesterday, I’ve finally got most of the formatting bugs worked out. I wasn’t thinking I was going to post this till I got about 2/3rd the way through it, so it’s pretty rough. Think of it as a look into my notebook. Enjoy.

One of the things I like about Scheme is the ability to seamlessly jump from code as code and code as data, or vice versa. This is called “Quoting” and it works something like this:

(define a-list '(1 2 3))
(define quoted-list 'a-list)
;;;;
a-list =: (1 2 3)
(eval quoted-list) =: (1 2 3)

Quoting allows us to pass things by name, and evaluated them as needed, that is, if I define a bit of scheme a la:

(define (stream generator initial-value)
   (define next-val (generator initial-value))
   (cons initial-value
        `(stream ,generator ,next-val)))

(define (head/s a-stream)
    (car a-stream))

(define (tail/s a-stream)
    (eval (cdr a-stream)))

(define naturals
    (stream (lambda (x) (+ x 1)) 0))

This will give a lazy-list function given a generator which operates on one initial value and inductively defines the next and so on. It uses something called “quasiquoting” which allows for partially quoted sexps. All we really do in the above is construct an infinite list one element at a time. When we call “head/s” we’re just taking the already computed value, when we call “tail/s”, we simply compute the second half of the cons pair, which we stored as the quoted function

`(stream ,generator ,next-val)

, which gives us a new stream (of the same form) but which has the next-value in the first position, and a new quoted function as:

`(stream ,generator ,(generator (eval (stream ,generator ,next-val))))

(more or less) This does exactly what Haskell does for it’s lazy-lists, (and it’s lazyness in general) it computes what it needs as you ask for it. However, we don’t have this neat quoting ability exposed in Haskell. So how can we recreate it?

Well, first of all, We need to examine exactly what a “quote” is, each of these different quote-functions, namely quote (written as ‘) quasi-quote (written as `) and unquote (written as ,), are just maps of the following form: Quotable a => a -> Quoted a Similarly, we need an inverse function, going from a Quoted a -> a. In scheme, we call this ‘eval’, for our case, let’s call it dequote- since eval is used for more than just quoting/dequoting. Dequote has the signature:

Quotable a => Quoted a -> a

and the property

> prop_inv x = x == (dequote . quote) x

holds. So, we notice one interesting thing, Quoting has a monadic looking signature, namely that ‘quote’ looks a good bit like ‘return’, in fact, quoting does form a monad under

(x >>= f) = (f . dequote) x
return x = quote x

Not a very interesting monad, but a monad nonetheless, a quick proof of the monad-ness of quoting is as follows: Left Identity:

(return x) >>= f = (f . dequote) $ (quote x)          -- definition
                                 = f . dequote . quote $ x -- definition
                                 = f . id $ x           -- prop_inv
                                 = f x                          -- identity property

Right Identitiy:

(x >>= return) = (quote . dequote) $ x -- definition
                         = id $ x            -- prop_inv
                         = x                 -- identity

Associativity:

(x >>= f) >>= g == (x >>= (\y -> f x >>= g))                      -- given
                                 == ((\y -> f x >>= g) . dequote $ x -- definition
                                 == f (dequote x) >>= g                    -- beta-reduction (iirc)
                                 == (g . dequote) $ f (dequote x)          -- definition
remember that, momentarily
(x >>= f) >>= g == (g . dequote) $ (f . dequote $ x) -- definition
                                 == (g . dequote) $ f (dequote x)        -- simplification
but this is the same as the above side, so the law holds.

I’m fairly sure that the definition

x >>= f = f . quote $ x
return x = dequote x

is a monad too. I’ll leave that as an excercise. A quick recap, we haven’t written any actual code yet, but we know that the two functions (quote/dequote) yield two monads. We might ask if it satisfies any other constraints. Before that, though, lets write up some code.

> newtype Quote a = Q a
> quote :: a -> Quote a
> quote = undefined -- we don't care how it's implemented, we just need to pretend
>                       -- it exists
> dequote :: Quote a -> a
> dequote = undefined

> instance Monad Quote where
>       return x = quote x
>       x >>= f = (f . dequote) x 

Note how we are only proving that these types check out- we’re not saying how to build this quoting mechanism, simply that if it does exist, then it has the property of being a monad. Later, we might try to actually build such a infrastructure, but for now, let’s just do some math. Specifically, lets look at whats available? One natural area to look at is functors and their applicative variants: Recall that a functor implies the structure can be mapped over, that is there exists some function:

fmap :: Functor f => (a -> b) -> f a -> f b

This obeys the following laws:

fmap id = id
fmap (f . g) = fmap f . fmap g

We can easily show Quote is a functor, a la:

> instance Functor Quote where
>       fmap f = (quote . f . dequote)

This satisfies the laws as follows:

fmap id = quote . id . dequote  -- hypothesis
                = quote . dequote       -- defn
                = id                    -- prop_inv

fmap (f . g) = fmap f . fmap g                                          -- hypothesis
                         = (quote . f . dequote . quote . g . dequote) -- defn
                         = (quote . f . id . g . dequote)              -- prop_inv
                         = (quote . f . g . dequote)                 -- defn
                         = fmap (f . g)                                                                 

So we have a functor and a monad, we can also show that it’s an applicative functor, a la:

> instance Applicative Quote where
>       pure            = quote
>       qf <*> qx       = fmap (dequote qf) qx 

That needs to satisfy the following:

Identity:
pure id <*> v = v

Composition:
pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism:
pure f <*> pure x = pure (f x)

Interchange:
u <*> pure y = pure ($ y) <*> u

We can show this also fairly easily:

Identity:
pure id <*> v = (quote id) <*> v                                -- defn
                         = fmap (dequote . quote . id) v        -- defn
                         = fmap (id . id) v                     -- prop_inv
                         = fmap id v                            -- defn
                         = v                                    -- functor law
Composition:
Left as an exercise

Homomorphism:
pure (f x) = pure f <*> pure x                        -- hypothesis
                 = (quote f) <*> (quote x)                    -- defn
                 = fmap ((dequote . quote) f) (quote x) -- defn
                 = fmap f (quote x)                           -- prop_inv
                 = pure (f x)                                 -- defn

Interchange:
Exercise                 

So, we’ve shown quoting to be a functor, applicative functor, and a monad. Possible interesting questions include: Is there a quote-identity? Which might give rise to a monoid instance? How many ways are there to implement this infrastructure? Obviously using read/show is nice, but would only allow quoting of read/show types, can we generalize it somehow? Can we somehow generalize this to a kind of class, meaning that we could have different quote/dequote functions, but still have a general monad instance for all of those types? Can we make quoting derivable?

In any case this was fun, I hope to come back sometime and actually implement some quoting ability for Haskell, but at least now I can see what kind of things that structure could do!

Sorry.

The posts will be aimed at laypersons with no mathematical experience beyond 10th grade or so, we’ll talk about geometry and algebra, basic statistics and numerical stuff, maybe even some more abstract stuff, but always presented from a practical point of view.

For the inagural post, Let’s talk about percentages, we’ll aim to look at percentages from a qualitative, practical viewpoint.

First, what is a percentage? Basically, a percentage is just a fraction, it represents a portion of a whole. The basic meaning of a percentage is simply that, for some numbers x and y, finding x-percent of y is the same as saying “calculate latex y/100x.” For instance, heres a simple word problem.

You’ve got a “pay two-thirds-price” coupon on your favorite coffee, Moroccan French Roast, it usually costs 7.99$ for a 1-lb bag of these delicious beans, but you only have a five in your pocket, can you afford the coffee?

So first, how do we say “pay two-thirds-price” in the language of Percentages? Remember that every percentage is really a fraction, and two-thirds is just the fraction 2/3. So we can easily convert this fraction using the definition I gave above, namely that:

x% of y = y/100x.

So, we can represent 2/3 = 0.6666… in decimal. So if we apply the definition, the percentage equivalent to two-thirds is 66.7% percent, or so. All that is useful, but when push comes to shove, we really can’t use this notation for percentages, it’s a nice way to look at them, but as far actual usefulness goes, we know alot more about the fractional representation, so we like to use that.

Back to our problem, we are simply asking how much two-thirds of 7.99 is, and whether that is more or less than 5 dollars. we can evaluate this quickly by using the following trick. 7.99 is the same as (8.00 - 0.01), now when we try to take 2/3s of 7.99, we can instead take 2/3s of 8 and 2/3s of 0.01, which is 5.33 and 0.006, we then take the latter value from the former, and we find that we have 5.27, or so. So no coffee for us.

Thats the fundamental problem in every percentage question. How do we convert to a fraction, and then how do we multiply quickly? The interesting stuff comes when we start to combine percentages, like stacking coupons, or finding out how well you did on a test, and similar.

Now lets start taking an algebraic slant. Think about the following problem.

You’re back at the store, and this time, you’re prepared, you have four 10% off coupons for you coffee, and that same fiver. The 1-lb bag still costs 7.99$, can you afford the coffee now?

So, the first question, what does “10% off” mean? Intuitively, it means that the store will subtract 10% of the price of the item if you have the coupon. So for any x%-off coupon, what we really have is that you’re going to pay (100-x)% of the price. So 10% off really means 90% of the price. Now heres the interesting part, with some number n 10% off coupons, you might suspect that you’ll get 10n% off, but this isn’t always the case, most places that will give you 10%-off coupons chain the coupons together, meaning they apply the first coupon to the original price, the second to the now discounted price, and so on. So instead of getting 60% off the price of our coffee, we’d be getting 10% off of 10% off of 10% and so on off of the original price.

What does this mean for our total discount? Well, converting the chain above, we need to find 90% of 90% of 90% of 90% of 90% of 90% of 7.99. Note that 100% of the price is 7.99, so we could write this as a product of fractions: 9/10 * 9/10 * … * 9/10. That’s basic algebra though, we just compute 9^4 / 10^4, using a calculator, we find that that is equal to 6561/10000, which is equal to the percentage 65.61% of the original price, which is equivalent to (100 - 65.61)% = 34.39% off. Again, using a calculator, we use the fractional representation of 65.61% of 7.99$, and find that it’s equal to: 5.24$. Damn, no coffee.

So, depending on how your local store combines coupons, you may be getting a bigger or smaller discount.

I’ll leave you folks with an exercise, Imagine that you’re taking the SATs. As many of you may know, the SAT’s recently redesigned their system to include three tests, with a possible 800 points each. You want to compare your scores with that of your older brother, who scored 1460 on the old “double-800’s” version[1]. You want to at least tie your older brothers score, how well do you have to do on the SAT’s to match your brothers score?

Remember that the SAT’s score in 10s, that is, you can’t score a 1423.52, you can only score in a multiple of ten.

The answer will appear in the next post in this series. Stay tuned!

[1] Yes, that is my real score on the SATs, I took them twice, that was the higher of the two (the first time I took them, I got a 1320, but I don’t like to talk about that.

To update the crowd, I’ve recently been working with Android, the Google Phone platform, specifically working on a simplified interface for interphone communication via the GTalk interface. I’ve also been fiddling with GPS stuff. I’ll be posting about that soon, and about a decentralized persistent game I’ve been hacking on in Haskell.

Sorry,

~~Joe