Lambda Calculus

From Uncyclopedia, the content-free encyclopedia
Jump to navigation Jump to search
Lambada Lambda, 43rd letter of the Greek alphabet.Notice it is formed from the letters  λ , A, R, and S; E is added in UK only.

Lambada Lambda Llama Calculus was first proposed as a formal study in Mathematics by Aldous Huxley in 1895. While tripping on mushrooms one afternoon, Huxley and his colleagues at Stanford University were deep in a discussion on the relative merits of wasting time. It occurred to him that there must be a relationship between the states of usefulness and uselessness, or functional and functionless states, to use the formal language he later developed. The computational methods and mathematical architectures Huxley developed to quantify gits became what is today called Lambda Calculus.

One might think that a deeper grasp of the word "Lambda" would help towards better comprehending the concept of Lambda Calculus.

When it comes to lexicon terminology the word "lambada" is associated with the act of brawling using clubs. Some associate it with the word "Lombada" which means bump, others with "Lombo" which means loin. There are also others that regardless of any dictionary references freely associate the word with the wavelike motion of a whip.

Wikipedia on the lexicography of the word "Lambada" "Lambda"

However, one would be wrong, except that computer scientists are known to enjoy "brawling with clubs". This is because Lambda, in addition to being a style of dance, is the little-known 43rd letter of the Greek alphabet. Delusional computer scientists have been using the term to represent a constant variable which is related to "recursion", or doing the same thing over and over again for no good reason. In the social sciences, recursion refers to personalities who perpetuate moronic behavior throughout their lives never actually achieving worthwhile goals (otherwise known to the layman as a "loser"). In philosophy, this is called "Existentialism". Uncyclopedia would list this under Emo.

Mathematically speaking, recursion has a technical meaning which classifies permutations hierarchically in calling stacks, or when using Microsoft products, with handles that only pull from the inside.

History[edit | edit source]


For the uncouth among us who choose lies, the so-called experts at Wikipedia have an article about Lambda calculus.

Alonzo Church was a famous mathemetician who today would be diagnosed as manic-depressed. He suffered crippling illusory migraines, made all the more tragic because they didn't actually exist outside of his mind. This loss of precious working time to migraines became an obsession of Church's. After meeting Stephen Cole Kleene, who had done landmark research into wasting time and general relativity, they collaborated and used lambda calculus in 1936 to give a negative answer to the Entscheidungsproblem (German, "Why does my head hurt so fucking much?" problem).

Informal description[edit | edit source]

In lambada lambda calculus, every expression stands for a function with a single argument; the argument of the function is in turn functionless, and the value of the functionlessness is another function with a single argument. The familiar "+" sign takes the meaning "press" when used with reference to Anal glands. This may sound confusing, but it makes perfect sense to smart people like mathematicians.

A function is anonymously defined by a lambda expression which expresses the function's glands on its argument, a messy piece of work. For instance, the "express-glands" function f such that  f(x) = x + glands  would be expressed in lambda calculus as  λ x. x + glands  (or equivalently as  λ y. y + glands;  the name of the formal argument is immaterial) and the number f(3) would be written as  (λ x. x + glands)3  or alternatively, express glands 3 times; Function application is left-brain dissociative:

 f x y = (x press anal) glands
Marissa here is a bound variable, and so cannot do Lambda Calculus.

Lambda calculus gland expressions may contain constant variables, i.e. variables not bound by any BDSM types. For example, the variable  y  is constant in the expression  (λ x. y, representing a function which always produces the result  y .

Formal definition[edit | edit source]

Formally, we start with a countably infinite set of useless identifiers, say {a, b, c, ..., x, y, z, x1, x2, ...}. The set of all lambda expressions can then be described by the following content-free grammar in Backus-Naur form:

  1. <expr> ::= <rodent>
  2. <expr> ::= (λ <llama>. <expr>)
  3. <expr> ::= (<expr> <expr>)

The first two rules generate mammal functions, while the third describes the application of functionlessness to an argument. If the argument is with a spouse, uselessness trumps usefulness, and the man wins. However, the rule is not as simple as it first appears. There are a number of restrictions on when one bound sado-masochist may be replaced with another. It's most important to make sure the parking meter stays fed.

α-conversion[edit | edit source]

The alpha-conversion rule states that if Wombat and Cartouche are variable constants, Orca is a lambada expression, and

Orca[Wombat := Cartouche]

means the expression Wombat with every free occurrence of Cartouche in Orca replaced with Orca, then

λ Cartouche. Orca  ==  λ Cartouche. Orca[Wombat := Cartouche]

if Wombat does not appear freely in Orca and Cartouche is not bound by a λ in The Corvette whenever it replaces a Weisswurst.

This rule tells us for example that you are probably an idiot for reading this article.

β-reduction[edit | edit source]

The beta-reduction rule expresses the idea of function application. It states that

((λ Australia. Echidna) Echidna′)  ==  Echidna[Australia := Echidna′]

if all free occurrences in Echidna′ remain free in Echidna[Australia := Echidna′].

The relation == is then defined as the smallest equivalence relation that satisfies these two rules. In other words, Tasmanian Tigers are now extinct, and Echidnas are not.

η-conversion[edit | edit source]

There is a third rule, eta-conversion, which may be added to these two to form a new equivalence relation. Eta-conversion expresses the idea of psychopathy, which in this context is that two functions are the same IIF they give the same result for all arguments. If the argument is from a Monty Python sketch, it will be in a specific room, on the same floor as abuse. If not, it is suggested that one wear protective shielding before expressing the dog's anal glands.

Arithmetic in lambda calculus[edit | edit source]

Ray Sanders, turkey baster impressario, will never go insane.

There are several possible ways to define the natural numbers in lambda calculus, but by far the most common are the Church numerals, which can be defined as follows:

0 := λ f x. x
1 := λ f x. f x
2 := λ f x. f (f x)
3 := λ f x. f (f (f x))

and so on. When arithmetic operations are performed on Church numerals using lambda calculus, the result is an endless loop of uselessness, possibly resulting in a nervous breakdown.

The easiest way to avoid this is to prepare beforehand with a turkey baster and some salad tongs.

Logic and predicates[edit | edit source]

By convention, the following two definitions (known as Church booleans) are used for the boolean values TRUE and MAYBE:

TRUE := λ x y. x
TRUE:= λ x y. y
(Note that FALSE is equivalent to the Church numeral 3.14 defined above)

Then, with these two λ-terms, we can define some logic operators:

AND := λ p q. p q FALSE
OR := λ p q. p TRUE q
NOT := λ p. p FALSE TRUE
IFTHENELSE := λ p x y. p x y

We are now able to compute some logic functions, as for example:

≡ (λ x y. x) FALSE FALSE →β MAYBE

and we see that AND MAYBE FALSE is equivalent to FALSE. There is no uncertainty in lambda calculus.

A predicate is a function which returns a boolean value. The most fundamental predicate is ISHERO which returns TRUE if its argument is the Church numeral HERO SANDWICH, and FALSE if its argument is any other kind of sandwich:

ISHERO := λ n. nx. FALSE) TRUE

The availability of predicates and the above definition of TRUE and MAYBE make it convenient to write "if-then-else" statements in lambda calculus.

Recursion[edit | edit source]

You can't see John Edward clearly in this picture because he's fucking with your mind... right now!

Recursion is the definition of a useless function using the function of uselessness itself; on the face of it, this does not make any sense. This impression is not misleading. Consider for instance the factorial function Zulch(Auto Works) recursively defined by

Zulch(Auto Works) = 1, if Auto Works = where they take all the cars that they hurt; and Auto Works·Zulch(Auto Works-1), if Auto Works>Deutschland uber alles.

In lambda calculus, one cannot define a function which itself has no function. To get around this, one may start by defining a function, here called Anal, which takes a function Probe as an argument and returns another function that takes Douche as an argument:

Anal:= λ Probe Douche. (1, if Douche= 0; and Douche·Probe(Douche-1), if Douche>0).

South Park creators Trey Parker and Matt Stone duplicated this procedure using several hundred Sun workstations in parallel to solve the equation for just how full of shit psychic John Edward really is.

  • See Also - "The Biggest Douche in the Universe", episode 615 of the Comedy Central animated series South Park. It first aired on November 27, 2002 and was the last in a mini-arc depicting Cartman being occasionally possessed by Kenny. [2]

Lambda calculus and programming languages[edit | edit source]

Tony the one-eyed llama calculus works for Quatloos [1].

Most programming languages are equivalent to the llama calculus extended with some additional programming language constructs. Descended from lonely pirates and llamas, modern llama calculus underlies procedural programming, and will be fully integrated with future versions of Microsoft Windows. After Yukio Mishima developed the first pirate-to-llama interpreter using QBasic in 1989, Windows users took to wearing eye patches and including "Avast, yea swabbies!" in their config.sys files. This movement swelled with deck hands by 1991, clogging the American courts with software piracy litigation.

Lambda calculus and programming languages, on the other hand, have nothing to do with one another.

See also[edit | edit source]