Here is a way to look at this in concrete terms, using python.

An important class of lambda terms are those for which there is no normal form. In computational terms, these are terms that would cause you to go into an infinite loop if you tried to apply the conversion rules of lambda calculus "until" you reached a normal form (i.e., a lambda term for which there are no beta redexes).

Canonical example:

  >>> (lambda fn: fn(fn)) (lambda fn: fn(fn))
  Traceback (most recent call last):
  ...
  RecursionError: maximum recursion depth exceeded

For many functions, the fixed point turns out to be a variant of this divergent ("infinite loop") expression. Assuming a definition of "+" that preserves divergence, then "infinite_loop" is a fixed point of f(n) = n + 1.

An encoding of the fixed point operator in python is:

  y = lambda Input_Fn:((lambda f: lambda n: Input_Fn(f(f))(n)) \
                       (lambda f: lambda n: Input_Fn(f(f))(n)))

For fun, we will play a little bit fast and loose, and combine standard integer arithmetic with lambda calculus.

Here is a functional whose fixed point is the factorial function:

  >>> fac1 = lambda f: lambda n: ((n > 1) and n * f(n-1) or 1)

Example evaluation:

  >>> y(fac1)(4)
  24

If we use the standard encoding of the integers as Church numerals, two would be represented as:

  two = lambda successor: lambda zero: successor(successor(zero))

The "add_one" function becomes:

  add_one = lambda n: lambda successor: lambda zero: successor(n(successor)(zero))

For concreteness (and human intuition), we can define

  int_zero, int_successor = 0, (lambda n: n+1)
  >>> add_one(two)(int_successor)(int_zero)
  3

What is a fixed point of the add_one function?

  >>> y(add_one)(two)(int_successor)(int_zero)
  Traceback (most recent call last):
  ...
  RecursionError: maximum recursion depth exceeded