Calculus 1 Lecture

[Prisc Chandola]

Thesevideo lectures of Professor David Jerison teaching 18.01 were recorded live in the Fall of 2007 and do not correspond precisely to the lectures taught in the Fall of 2006 (e.g., the lecture notes).

As well, here are some hard to find videos corresponding to the 11th edition of Thomas Calculus that I enjoyed a long time ago. While the book links all appear to be dead, and not all of the videos work, most of the videos do work, and the deliverers are outstanding: Thomas.

You may find Adrian Banner's Calculus Lifesaver course useful. The series of 24+ videos are available at and are also provided on the iTunes Store as Podcasts. The quality of the videos is variable, but the exposition is thorough, and his style is engaging.

NOTE: In Video lecture for Multi-variable Calculus by Edward Frenkel of UC berkeley, in the first lecture he is referring to an equation (function y=f(x)) and he says that there are 2 "independent" variables and 1 equation, so number of independent variables minus number of equations gives us the dimension.

The video lectures at the "best" schools tend to be less systematic and orderly. All are useful, but if you are using videos to self-teach I would suggest the UMKC calculus 1 lectures by Delaware. There is no live audience, and thus no stammering, no showing up and teaching off the top of one's head. More progressive and orderly.

I highly recommend learning Calculus from the ground up with Professor Leonard. His video lectures are comprehensive, comprehensible, and help the math stick long after you've watched his videos. I completed his Calc 1 and Calc 2 courses. I am halfway through his Calc 3 videos. I suggest starting here: =PLF797E961509B4EB5

Today we will take a look at the theoretical roots of functional programming in the formof a mathematical precursor to OCaml,the λ- (lambda-) calculus. The λ-calculuswas invented by Alonzo Church in the 1930s to study the interaction of functionalabstraction and function application from an abstract, purely mathematical pointof view.

It was one of many related systems that were proposed in the late 1920s and 1930s. This was anexciting time for theoretical computer science, even though computers had not yetbeen invented. There were many great mathematicians such as Alonzo Church, Kurt Gdel, AlanTuring, and Emil Post who were trying to understand the notion of computation. They certainly understood intuitively what an algorithm was, but they werelacking a formal mathematical definition. They came up with a number ofdifferent systems for capturing the general idea of computation:

These systems alllooked very different, but what was amazing was that they all turned out tobe computationally equivalent in the sense that each could encode andsimulate the others. Church thought that this was too striking to be merecoincidence, and declared that they had found the correct definition of thenotion of computability: it was the common spirit embodied in a different wayby each one of these formalisms. This declaration became known as Church'sthesis. Nowadays we have a better understanding of computability, andone could add any modern general-purpose programming language such as Java, C, Scheme,or OCaml (suitably abstracted) to this list, but Church and his colleagues didnot have that luxury.

In the λ-calculus, a reduction rule can be performed at any time to any subterm of a λ-termat which the rule is applicable. OCaml specifies an order of evaluation, but the λ-calculus does not. Itturns out that it does not matter because of the Church-Rosser theorem: If E=> F1 and E =>F2, then there always exists a G such that F1 => G and F2 => G.

A λ-term is said to be in normal form if there are no β-reductionsthat apply; that is, if there are no subterms of the form (λx.M)N. For example, the terms x and λx.y are in normal form. Terms innormal form correspond to values in OCaml. They are objects thatcannot be evaluated further.

A term is said to be normalizable if there is a sequence of α-and β-reductions that lead to a normal form. Because of the Church-Rosser property, if a term is normalizable, then itsnormal form is unique (up to α-conversion). Asequence of reductions leading to a normal form corresponds roughly to a haltingcomputation in OCaml.

Some terms are not normalizable. For example, (λx.xx)(λx.xx)is not. Even if a term is normalizable, there may be infinite reductionsequences that never lead to a normal form. For example, (λy.z)((λx.xx)(λx.xx))reduces to the normal form z if it is evaluated lazily, but does notterminate if evaluated eagerly.

In OCaml, all the pairing operator ( , ) does is package up two things in such a way that they can be extractedagain by fst and snd. To code this in the λ-calculus, we can take twoterms A and B and produce a function that will apply another function to them. Define

In OCaml,numbers are a built-in primitive type. In the λ-calculus, we have toencode them as λ-terms. Church came up with a neat way to do this. His encoding iscalled the Church numerals. The idea is to encode the number n as a λ-termn representing a functionthat takes another function f as input and produces the n-fold composition off with itself.

These lectures are aimed at first year undergraduates. They describe the basics of div, grad and curl and various integral theorems. The lecture notes are around 120 pages. Please do email me if you find any typos or mistakes.

"I shall conclude by proposing for the consideration of mathematicians certain phrases... I should be greatly obliged to anyone who can give me suggestions onthis subject, as I feel that the onomastic power is very faint in me."

University Calculus I courses serve as a means of access into high demand STEM fields and large lecture style passive calculus courses can be difficult for students. A mixed methods research design was used to compare a flipped instructional approach to a traditional lecture approach in large section Calculus I courses. The flipped lecture model required students to view videos of calculus instruction that included embedded quiz questions to allow for problem solving explorations during face-to-face class time. The traditional format included content from the video and limited time for additional problem solving. A professor with prior experience teaching Calculus I taught both sections. The results showed that students in the flipped class scored significantly higher on the final exam than the students in the traditional class. Student pass rates in the two Calculus I courses were found to be significantly affected by the lecture type, sex, race, and college affiliation. According to a logistic regression model, students who were in the flipped section had increased odds of passing Calculus I compared to the students in the traditional section. The students and instructor identified benefits and challenges of the flipped lecture model that are included in the results. Through the flipped lecture model, increased time was spent on active learning and student outcomes were improved in a large lecture calculus course.

Curriculum and Instruction Commons, Educational Assessment, Evaluation, and Research Commons, Educational Methods Commons, Scholarship of Teaching and Learning Commons, Science and Mathematics Education Commons

At the end of Lecture 6 we tried our hand at "baking in"booleans into the lambda calculus, to try to ease the pain of writing everything using Church encodings.This seemed like a natural evolution of the pure calculus,but in fact created a big problem:we were able to write well-formed terms that "got stuck",in the sense that they were not values but could not be reduced further.For example, this term:

You might recognize this sort of problem from your prior programming experience.It's the sort of thing we'd call a "type error".Informally, a term like 7 + (λx. x) is trying to add things "of the wrong type",and that should be considered an error in the program,ideally an error we detect at compile time.In other words, this program should somehow be "invalid".

In this lecture, we'll formalize this idea of only some programs being "valid"by designing a type system for the (extended) lambda calculus.A type system will assign a type to terms in the lambda calculus,and we'll aim to design our type system to satisfy a simple safety propertythat Robin Milner phrased better than I could:

In other words, a type is either bool or ->, with the understanding that we'd use -> for anyabstraction and bool for any boolean. But this analysis is too conservative and not super helpful;for example, it assigns the same type -> to the two terms:

To give a useful type to an application, then,we need some way oto know what type the function being applied returns.We also need to know that the function will do the right thing with the argument we pass in,so somehow we also need to talk about the type of the argument.These requirements hint at a slightly richer type system that is inductive:

Here, the function type T -> T records both the type of the input (before the arrow)and the type of the result (after the arrow).The lambda calculus only has single-argument abstractions,so this is all we need,but we can compose the -> constructor to get more complex functions.For example, T1 -> (T2 -> T3) is the type of a function that takes as input a T1and returns a function that takes as input a T2 and returns a T3.

We''ve just about finished defining our type system,but there's one more thing to notice.In general, we might need more than one assumption to type a term with nested abstractions.To keep track of these assumptions, we introduce a typing context,conventionally written $\Gamma$,that maps variables to their types.(We have to be careful about capture avoidance again here;we assume that variables will be renamed as necessary to avoid capturing).To extend a typing context $\Gamma$ with an additional assumption we use a comma:$\Gamma, x : T$.

3a8082e126