Recursion in the lambda calculus works because although functions don't have names in the lambda calculus, their arguments do.  And you can pass a function as an argument to a lambda expression and handle recursion this way.

ADD_HELPER =

Lx.Ly.Lf.(((COND (ISZERO x)) y) ((f (PRED x)) (SUCC y)))

2+5
1+6
0+7
7

ADD = Lx.Ly.(((ADD_HELPER x) y) ADD_HELPER)

Recursion works in just this way.

How do you know if a "language" is Turing-Complete

Can you do a sequence of commands?

YES.  SELECT_SECOND = Lx.Ly.y

Lx.Ly.((SELECT_SECOND) x) y)  evaluates x and y returns the value of y.

Can you do an if-then-else?

Lx.Ly.((COND) x) y) returns x if COND is true and y if COND is false.

Can you do a loop?

Yes, you can, with a form of tail recursion.

LOOP2 =

Lf.((SELECT_SECOND PRE_TEST)
       (((COND TEST) RESULT)
       ((SELECT_SECOND POST_TEST) f)))

If you imagine a loop as being

 do
  <Pre-test stuff>
 until test
  <Post-test stuff>
 end do

LOOP = (LOOP2 LOOP2)

Can you do arithmetic over nonnegative integers?  YES.

EQUAL  How do we tell if two numbers are equal?
We already have ISZERO, and we already have PRED and SUCC.

EQUAL_HELPER =

 Lx.Ly.Lf.(((COND (ISZERO x)) (((COND (ISZERO y)) TRUE) FALSE))
          (((COND (ISZERO y)) FALSE) ((f (PRED x)) (PRED y))))

EQUALS = Lx.Ly.(((EQUAL_HELPER x) y) EQUAL_HELPER)

EQUALS, like all lambda expressions, takes one argument and evaluates to one expression.

((EQUALS FIVE) SEVEN), it's not like EQUALS is taking the two arguments, FIVE and SEVEN.  It is only FIVE...and evaluates to an expression that
specifically tests whether its argument is equal to FIVE.

(EQUALS FIVE) gives you another function, one that evaluates to TRUE
if the argument is FIVE and FALSE otherwise.

Some people look like at lambda calculus like this:

f(a,b) is REALLY:  f(a) (b).  functions with multiple arguments are thought of as functions taking one argument, returning another function, and applying that to the second argument.

You can think of multiple arguments to a function in that way, BUT there
are other ways, too.

For example, you can make ordered pairs in the lambda calculus, and you can these pairs as arguments to functions as well, and in this way, it's "like" you're passing two things.

There is no lambda expression:

Lx.Ly.((EQUAL_FUNCTION x) y)

that takes two functions x and y and returns TRUE if they always do the same thing and FALSE if they don't.

function f computes a certain important thing.

function g :  return f(x) + 0
function h:  return g(x) + 0


Logic can be converted to arithmetic.

True is 1 and false is zero.
P and Q ==> P*Q
P or Q ==> P+Q - P*Q

if (P) then (Q) else (R)
P*Q + (1-P)*R

if P then Q ==> NOT P OR Q