Lambda Calculus: The foundation of functional programming, and the simplest programming language

Lambda "Calculus" is a extremely concise way to represent logic and computing - just like a Turing machine. Instead of a Turing machine's mechanical and step by step way of computing, lambda calculus looks much more similar to regular math and "computes" by substituting and simplifying.
Timestamps:
00:00 intro
00:36 logical explanation
02:20 formal explanation
06:47 currying
08:47 church encoding for numbers
12:02 recursion
--------------
My website: tonyzhang.net
My Github: github.com/Tony1324
Contact me: [e-mail]

[@RoseS-mf8ye]

This is the best lambda calculus video I've watched of all. Thank you!

[@herbiejames5637]

Obviously understanding the value of lambda calculus is in exploring how robust it is on an abstract level, but it would be great to see this in an applied context as well! Thank you for your content!

[@giuliopimenoff]

Thank you so much, this was such a great explanation

[@miketurn5]

Extremely interesting way of computing already curious to learn more about catergory theory!

[@primenumberbuster404]

Haskell is goated

[@irok1]

Multiplication without recursion was crazy to see. Really showcases the possibilities of lambda calculus.
Great video, any chance you could increase your volume slightly?

[@anakimluke]

thanks for the video! I find the topic so interesting!

[@anakimluke]

ps. your next video is on category theory!!?? even more interested now!!

[@matematicke_morce]

Great video, by far the best explanation I've seen on the topic! My only critique is that the animations were a bit too fast, especially in the part about basic arithmetic operations

[@blueoxygenurawr404]

ikrr speedy gonazalez

[@101nka]

Great video! well explained

[@monsterhunter8595]

Very good video!

[@nilcipher1351]

I finally understand the y-combinator now.

[@ivandrofly]

Good one thanks

[@chakkawatsonaruea5088]

Great video.
I wished you putting a little more emphasis on, explicit putting parentheses on lambda abstraction vs no explicit parentheses.
For example:
Lambda x.x y
Is different then:
(Lambda x.x) y
Sorry if bad English.

[@TonyZhang01]

Definitely. I hoped that the use of parentheses was pretty clear based on the examples and what I wrote, and also because it is used the same way as they are normally used, so if I focused on talking about it it might seem more confusing than it actually is

[@beantown_billy2405]

3:05 does the function return itself (i.e. return a function), or the value it received?

[@raphaeld9270]

It is an error in the video it seems : `f(x) =x ` is the Identity function and just returns the input value as its output.
12:26 is closer to a function that "returns itself".

[@LambdaJack]

Which function!? A composition specialized to it's recursive specialization is it's recursive specialization.
A better name than Y could be "recursive", as in "(recursive compositio)". "id" as composition does not _specify_ at all what should be done, so it could be anything.
As a Degenerate Case a Composition can take the Self-Reference and do nothing with it.

[@beantown_billy2405]

@@LambdaJack The function at 3:05, f(x)=x

[@joejeffrey1436]

Instead of using church encodings a great alternative is PCF xx

[@tsunningwah3471]

有沒有中文的

[@jacobcohen76]

First!

[@incognitohacks4850]

Ackshually

[@alonelyphoenix8942]

Why

[@paulomarcos.5585]

λ Beautiful λ

[@basilalharbi3293]

Second

[@tsunningwah3471]

chinz

[@user-je7dq7uc9m]

The quality of information Is exelent but the way how It Is explained Is really low level. Really Fast to have time to be understand. Sonetimes It looks that It Is an automatic voice that speak.
I really Belive that this video Is superwow for the content but It Is terribly hard to really understand the content.

[@MarkVolkmann]

You say that the full definition of the add function is 🐑fxmn. (m f) (n f x). Sorry, I haven’t found a way to input the lambda character on an iPad, so I used the lamb emoji.
How can I walk through the steps to apply that function? Is it like this?
🐑fxmn. (m f) (n f x) f x 2 3
(2 f) (3 f x)
What do I do from here?

[@MarkVolkmann]

I think I found an answer.
(λfxmn. (m f) (n f x)) 2 3
-- Substitute 2 for m and 3 for n.
λfx. (2 f) (3 f x)
-- Substiture the λ terms for 2 and 3.
λfx. (λfx.f (f x) f) (λfx.f (f (f x)) f x)
-- Apply the arguments f and x in the last term.
λfx. (λfx.f (f x) f) (f (f (f x)))
-- Apply the argument f in the last term.
λfx. (λx.f (f x)) (f (f (f x)))
-- Apply the argument `(f (f (f x)))` to the function on its left.
λfx. f (f (f (f (f x))))
-- This is the definition of the number 5.

[@MarkVolkmann]

I haven’t been able to work out a similar set of steps to demonstrate multiplication though. I could use help with that.