|
|
| Line 1: |
Line 1: |
| {{distinguish2|[[combinational logic]], a topic in digital electronics}}
| | Checking body weight found on the scale is an simple means to keep track of progress whenever following an exercise regimen, nevertheless it is not the most accurate measure of total health. A better indicator of wellness plus progress is body fat percentage.<br><br>Number 6. Visit the venue before the wedding date, when possible. May it be within the easy backyard of the groom or the cliff of an island, it is very highly recommended to visit the region where the ceremony is held. This can help we greatly for it you will recognize what to expect and tackle. Just observe your step, assuming you'll shoot at the mountains.<br><br>Missing 1 can waist to height ratio sound fine, yet the earlier cancer or alternative condition is found, the easier it is very to treat it. Leaving this test out is the health equivalent of Russian roulette.<br><br>I went back to the same clinic plus spoke to a different doctor- by that time, nodules had shown up on my neck plus were very painful. How wonderful to find out a small pill might solve all the mysterious issues which hit me like a ton of bricks. True, I'll be taking it for the rest of my lifetime, yet I reside a happy plus healthy existence.<br><br>So when this is happening to we plus you don't wish To be apple shaped, what are you able to do regarding it. First, look at your diet. Cut out processed foods plus saturated fat. Items like butter, cakes, biscuits, full fat milk, white bread, ready produced meals.<br><br>According to the article "What Would the Real Barbie Look Like" inside the BBC News Magazine on Friday March 2, 2009 if Barbie were 5'6" then her waist will be 20", her hips 29" and bust a mere 27". The nearest real persons to those measurements are Victoria Beckham with a 23" waist plus Brigitte Bardot with a 20" waist. Both ladies are pretty famous, extremely skinny and absolutely not a average. According to the measurements of [http://safedietplansforwomen.com/waist-to-height-ratio waist to height ratio] a Barbie figure will be achieved by 1 inside 100,000 women plus a Ken figure might be accomplished in 1 in fifty guys.<br><br>Katherine M. Flegal; Barry I. Graubard; David F. Williamson; Mitchell H. Gail. Excess Deaths Associated With Underweight, Overweight, plus ObesityJAMA, April 20, 2005; 293: 1861 - 1867.<br><br>I was most satisfied and impressed with all the overall results. The right thing for me now is that I don't have to exercise all of the time to stay fit. I have absolutely invested enough time plus income following those traditional techniques like going to gym plus functioning out for hours. |
| {{bots|deny=D6,AWB}}
| |
| '''Combinatory logic''' is a notation to eliminate the need for [[Variable (mathematics)|variables]] in [[mathematical logic]]. It was introduced by [[Moses Schönfinkel]] and [[Haskell Curry]] and has more recently been used in [[computer science]] as a theoretical model of [[computation]] and also as a basis for the design of [[functional programming languages]]. It is based on '''combinators'''. A combinator is a [[higher-order function]] that uses only function application and earlier defined combinators to define a result from its arguments.
| |
| | |
| ==Combinatory logic in mathematics==
| |
| Combinatory logic was originally intended as a 'pre-logic' that would clarify the role of [[quantifier|quantified variables]] in logic, essentially by eliminating them. Another way of eliminating quantified variables is [[Willard Van Orman Quine|Quine's]] [[predicate functor logic]]. While the [[expressive power]] of combinatory logic typically exceeds that of [[first-order logic]], the expressive power of [[predicate functor logic]] is identical to that of first order logic ([[#Quine 1960 1966|Quine 1960, 1966, 1976]]).
| |
| | |
| The original inventor of combinatory logic, [[Moses Schönfinkel]], published nothing on combinatory logic after his original 1924 paper, and largely ceased to publish after [[Joseph Stalin]] consolidated his power in 1929.{{Citation needed|date=April 2013}} [[Haskell Curry]] rediscovered the combinators while working as an instructor at [[Princeton University]] in late 1927.<ref name="Seldin 2006">{{cite journal|last=Seldin|first=Jonathan|title=The Logic of Curry and Church}}</ref> In the latter 1930s, [[Alonzo Church]] and his students at [[Princeton University|Princeton]] invented a rival formalism for functional abstraction, the [[lambda calculus]], which proved more popular than combinatory logic. The upshot of these historical contingencies was that until theoretical computer science began taking an interest in combinatory logic in the 1960s and 1970s, nearly all work on the subject was by [[Haskell Curry]] and his students, or by [[Robert Feys]] in [[Belgium]]. Curry and Feys (1958), and Curry ''et al.'' (1972) survey the early history of combinatory logic. For a more modern parallel treatment of combinatory logic and the lambda calculus, see [[Henk Barendregt|Barendregt]]<!-- correct person? --> (1984), who also reviews the [[model theory|models]] [[Dana Scott]] devised for combinatory logic in the 1960s and 1970s.
| |
| <!-- This section needs a LOT of filling in!!! --> | |
| | |
| ==Combinatory logic in computing==
| |
| In [[computer science]], combinatory logic is used as a simplified model of [[computation]], used in [[computability theory]] and [[proof theory]]. Despite its simplicity, combinatory logic captures many essential features of computation.
| |
| | |
| Combinatory logic can be viewed as a variant of the [[lambda calculus]], in which lambda expressions (representing functional abstraction) are replaced by a limited set of ''combinators'', primitive functions from which [[bound variable]]s are absent. It is easy to transform lambda expressions into combinator expressions, and combinator reduction is much simpler than lambda reduction. Hence combinatory logic has been used to model some [[non-strict programming language|non-strict]] [[functional programming]] languages and [[graph reduction machine|hardware]]. The purest form of this view is the programming language [[Unlambda]], whose sole primitives are the S and K combinators augmented with character input/output. Although not a practical programming language, Unlambda is of some theoretical interest.
| |
| | |
| Combinatory logic can be given a variety of interpretations. Many early papers by Curry showed how to translate axiom sets for conventional logic into combinatory logic equations (Hindley and Meredith 1990). Dana Scott in the 1960s and 1970s showed how to marry [[model theory]] and combinatory logic.
| |
| | |
| == Summary of the lambda calculus ==
| |
| {{main|lambda calculus}}
| |
| | |
| The lambda calculus is
| |
| concerned with objects called ''lambda-terms'', which are strings of
| |
| symbols of one of the following forms:
| |
| | |
| * ''v''
| |
| * ''λv''.''E1''
| |
| * (''E1'' ''E2'')
| |
| | |
| where ''v'' is a variable name drawn from a predefined infinite set of
| |
| variable names, and ''E1'' and ''E2'' are lambda-terms.
| |
| | |
| Terms of the form ''λv.E1'' are called ''abstractions''. The variable ''v'' is
| |
| called the [[formal parameter]] of the abstraction, and ''E1'' is the ''body''
| |
| of the abstraction. The term ''λv.E1'' represents the function which, applied
| |
| to an argument, binds the formal parameter ''v'' to the argument and then
| |
| computes the resulting value of ''E1''---that is, it returns ''E1'', with
| |
| every occurrence of ''v'' replaced by the argument.
| |
| | |
| Terms of the form ''(E1 E2)'' are called ''applications''. Applications model
| |
| function invocation or execution: the function represented by ''E1'' is to be
| |
| invoked, with ''E2'' as its argument, and the result is computed. If ''E1''
| |
| (sometimes called the ''applicand'') is an abstraction, the term may be
| |
| ''reduced'': ''E2'', the argument, may be substituted into the body of ''E1''
| |
| in place of the formal parameter of ''E1'', and the result is a new lambda
| |
| term which is ''equivalent'' to the old one. If a lambda term contains no
| |
| subterms of the form ''((λv.E1) E2)'' then it cannot be reduced, and is said to
| |
| be in [[Beta normal form|normal form]].
| |
| | |
| The expression ''E''[''v'' := ''a''] represents the result of taking the term ''E'' and replacing all free occurrences of ''v'' with ''a''. Thus we write
| |
| | |
| :(''λv.E'' ''a'') => ''E''[''v'' := ''a'']
| |
| | |
| By convention, we take ''(a b c d ... z)'' as short for ''(...(((a b) c) d) ... z)''. (i.e., application is [[Associative#Non-associativity|left associative]].)
| |
| | |
| The motivation for this definition of reduction is that it captures
| |
| the essential behavior of all mathematical functions. For example,
| |
| consider the function that computes the square of a number. We might
| |
| write
| |
| | |
| :The square of ''x'' is ''x''*''x''
| |
| | |
| (Using "*" to indicate multiplication.) ''x'' here is the [[formal parameter]] of the function. To evaluate the square for a particular
| |
| argument, say 3, we insert it into the definition in place of the
| |
| formal parameter:
| |
| | |
| :The square of 3 is 3*3
| |
| | |
| To evaluate the resulting expression 3*3, we would have to resort to
| |
| our knowledge of multiplication and the number 3. Since any
| |
| computation is simply a composition of the evaluation of suitable
| |
| functions on suitable primitive arguments, this simple substitution
| |
| principle suffices to capture the essential mechanism of computation.
| |
| Moreover, in the lambda calculus, notions such as '3' and '*' can be
| |
| represented without any need for externally defined primitive
| |
| operators or constants. It is possible to identify terms in the
| |
| lambda calculus, which, when suitably interpreted, behave like the
| |
| number 3 and like the multiplication operator, q.v. [[Church encoding]].
| |
| | |
| The lambda calculus is known to be computationally equivalent in power to
| |
| many other plausible models for computation (including [[Turing machine]]s); that is, any calculation that can be accomplished in any
| |
| of these other models can be expressed in the lambda calculus, and
| |
| vice versa. According to the [[Church-Turing thesis]], both models
| |
| can express any possible computation.
| |
| | |
| It is perhaps surprising that lambda-calculus can represent any
| |
| conceivable computation using only the simple notions of function
| |
| abstraction and application based on simple textual substitution of
| |
| terms for variables. But even more remarkable is that abstraction is
| |
| not even required. ''Combinatory logic'' is a model of computation
| |
| equivalent to the lambda calculus, but without abstraction. The advantage
| |
| of this is that evaluating expressions in lambda calculus is quite complicated
| |
| because the semantics of substitution must be specified with great care to
| |
| avoid variable capture problems. In contrast, evaluating expressions in
| |
| combinatory logic is much simpler, because there is no notion of substitution.
| |
| | |
| == Combinatory calculi ==
| |
| | |
| Since abstraction is the only way to manufacture functions in the
| |
| lambda calculus, something must replace it in the combinatory
| |
| calculus. Instead of abstraction, combinatory calculus provides a
| |
| limited set of primitive functions out of which other functions may be
| |
| built.
| |
| | |
| === Combinatory terms ===
| |
| | |
| A combinatory term has one of the following forms:
| |
| *''x''
| |
| *''P''
| |
| *(''E<sub>1</sub>'' ''E<sub>2</sub>'')
| |
| where ''x'' is a variable, ''P'' is one of the primitive functions, and (''E<sub>1</sub>'' ''E<sub>2</sub>'') is the application of combinatory terms ''E<sub>1</sub>'' and ''E<sub>2</sub>''. The primitive functions themselves are ''combinators'', or functions that, when seen as lambda terms, contain no [[free variable]]s.
| |
| To shorten the notations, a general convention is that (''E<sub>1</sub>'' ''E<sub>2</sub>'' ''E<sub>3</sub>'' ... ''E<sub>n</sub>''), or even ''E<sub>1</sub>'' ''E<sub>2</sub>'' ''E<sub>3</sub>''... ''E''<sub>n</sub>, denotes the term (...((''E<sub>1</sub>'' ''E<sub>2</sub>'') ''E<sub>3</sub>'')... ''E<sub>n</sub>''). This is the same general convention (left-associativity) as for multiple application in lambda calculus.
| |
| | |
| === Reduction in combinatory logic ===
| |
| | |
| In combinatory logic, each primitive combinator comes with a reduction rule of the form
| |
| | |
| :(''P'' ''x<sub>1</sub>'' ... ''x<sub>n</sub>'') = ''E''
| |
| | |
| where ''E'' is a term mentioning only variables from the set ''x<sub>1</sub>'' ... ''x<sub>n</sub>''. It is in this way that primitive combinators behave as functions.
| |
| | |
| === Examples of combinators ===
| |
| | |
| The simplest example of a combinator is '''I''', the identity
| |
| combinator, defined by
| |
| | |
| :('''I''' ''x'') = ''x''
| |
| | |
| for all terms ''x''. Another simple combinator is '''K''', which
| |
| manufactures constant functions: ('''K''' ''x'') is the function which,
| |
| for any argument, returns ''x'', so we say
| |
| | |
| :(('''K''' ''x'') ''y'') = ''x''
| |
| | |
| for all terms ''x'' and ''y''. Or, following the convention for
| |
| multiple application,
| |
| | |
| :('''K''' ''x'' ''y'') = ''x''
| |
| | |
| A third combinator is '''S''', which is a generalized version of
| |
| application:
| |
| | |
| :('''S''' ''x'' ''y'' ''z'') = (''x'' ''z'' (''y'' ''z''))
| |
| | |
| '''S''' applies ''x'' to ''y'' after first substituting ''z'' into
| |
| each of them. Or put another way, ''x'' is applied to ''y'' inside the
| |
| environment ''z''.
| |
| | |
| Given '''S''' and '''K''', '''I''' itself is unnecessary, since it can
| |
| be built from the other two:
| |
| | |
| :(('''S''' '''K''' '''K''') ''x'')
| |
| :: = ('''S''' '''K''' '''K''' ''x'')
| |
| :: = ('''K''' ''x'' ('''K''' ''x''))
| |
| :: = ''x''
| |
| | |
| for any term ''x''. Note that although (('''S''' '''K''' '''K''')
| |
| ''x'') = ('''I''' ''x'') for any ''x'', ('''S''' '''K''' '''K''')
| |
| itself is not equal to '''I'''. We say the terms are [[extensional equality|extensionally equal]]. Extensional equality captures the
| |
| mathematical notion of the equality of functions: that two functions
| |
| are ''equal'' if they always produce the same results for the same
| |
| arguments. In contrast, the terms themselves, together with the
| |
| reduction of primitive combinators, capture the notion of
| |
| ''intensional equality'' of functions: that two functions are ''equal''
| |
| only if they have identical implementations up to the expansion of primitive
| |
| combinators when these ones are applied to enough arguments. There are many ways to
| |
| implement an identity function; ('''S''' '''K''' '''K''') and '''I'''
| |
| are among these ways. ('''S''' '''K''' '''S''') is yet another. We
| |
| will use the word ''equivalent'' to indicate extensional equality,
| |
| reserving ''equal'' for identical combinatorial terms.
| |
| | |
| A more interesting combinator is the [[fixed point combinator]] or '''Y''' combinator, which can be used to implement [[recursion]].
| |
| | |
| === Completeness of the S-K basis ===
| |
| | |
| It is perhaps astonishing that '''S''' and '''K''' can be
| |
| composed to produce combinators that are extensionally equal to
| |
| ''any'' lambda term, and therefore, by Church's thesis, to any
| |
| computable function whatsoever. The proof is to present a transformation,
| |
| ''T''[ ], which converts an arbitrary lambda term into an equivalent
| |
| combinator.
| |
| | |
| ''T''[ ] may be defined as follows:
| |
| | |
| # ''T''[''x''] => ''x''
| |
| # ''T''[(''E₁'' ''E₂'')] => (''T''[''E₁''] ''T''[''E₂''])
| |
| # ''T''[''λx''.''E''] => ('''K''' ''T''[''E'']) (if ''x'' does not occur free in ''E'')
| |
| # ''T''[''λx''.''x''] => '''I'''
| |
| # ''T''[''λx''.''λy''.''E''] => ''T''<nowiki>[</nowiki>''λx''.''T''<nowiki>[</nowiki>''λy''.''E''<nowiki>]]</nowiki> (if ''x'' occurs free in ''E'')
| |
| # ''T''[''λx''.(''E₁'' ''E₂'')] => ('''S''' ''T''[''λx''.''E₁''] ''T''[''λx''.''E₂'']) (if ''x'' occurs free in ''E₁'' or ''E₂'')
| |
| This process is also known as ''abstraction elimination''.
| |
| | |
| It is related to the process of ''bracket abstraction'', which takes an expression ''E'' built from variables and application and produces a combinator expression [x]E in which the variable x is not free, such that [''x'']''E'' ''x'' = ''E'' holds.
| |
| A very simple algorithm for bracket abstraction is defined by induction on the structure of expressions as follows:<ref name="Turner 1979">{{cite journal|last=Turner|first=David A.|title=Another Algorithm for Bracket Abstraction|journal=The Journal of Symbolic Logic|issue=44|pages=267–270|url=http://www.jstor.org/discover/10.2307/2273733?sid=21101449563731}}</ref>
| |
| # [''x'']''y'' := '''K''' ''y''
| |
| # [''x'']''x'' := '''I'''
| |
| # [''x''](''E₁'' ''E₂'') := '''S'''([''x'']''E₁'')([''x'']''E₂'')
| |
| Bracket abstraction induces a translation from lambda terms to combinator expressions, by interpreting lambda-abstractions using the bracket abstraction algorithm.
| |
| | |
| ==== Conversion of a lambda term to an equivalent combinatorial term ====
| |
| | |
| For example, we will convert the lambda term ''λx''.''λy''.(''y'' ''x'') to a
| |
| combinator:
| |
| | |
| :''T''[''λx''.''λy''.(''y'' ''x'')]
| |
| :: = ''T''<nowiki>[</nowiki>''λx''.''T''<nowiki>[</nowiki>''λy''.(''y'' ''x'')<nowiki>]]</nowiki> (by 5)
| |
| :: = ''T''[''λx''.('''S''' ''T''[''λy''.''y''] ''T''[''λy''.''x''])] (by 6)
| |
| :: = ''T''[''λx''.('''S''' '''I''' ''T''[''λy''.''x''])] (by 4)
| |
| :: = ''T''[''λx''.('''S''' '''I''' ('''K''' ''x''))] (by 3 and 1)
| |
| :: = ('''S''' ''T''[''λx''.('''S''' '''I''')] ''T''[''λx''.('''K''' ''x'')]) (by 6)
| |
| :: = ('''S''' ('''K''' ('''S''' '''I''')) ''T''[''λx''.('''K''' ''x'')]) (by 3)
| |
| :: = ('''S''' ('''K''' ('''S''' '''I''')) ('''S''' ''T''[''λx''.'''K'''] ''T''[''λx''.''x''])) (by 6)
| |
| :: = ('''S''' ('''K''' ('''S''' '''I''')) ('''S''' ('''K''' '''K''') ''T''[''λx''.''x''])) (by 3)
| |
| :: = ('''S''' ('''K''' ('''S''' '''I''')) ('''S''' ('''K''' '''K''') '''I''')) (by 4)
| |
| | |
| If we apply this combinator to any two terms ''x'' and ''y'', it
| |
| reduces as follows:
| |
| | |
| : ('''S''' ('''K''' ('''S''' '''I''')) ('''S''' ('''K''' '''K''') '''I''') x y)
| |
| :: = ('''K''' ('''S''' '''I''') x ('''S''' ('''K''' '''K''') '''I''' x) y)
| |
| :: = ('''S''' '''I''' ('''S''' ('''K''' '''K''') '''I''' x) y)
| |
| :: = ('''I''' y ('''S''' ('''K''' '''K''') '''I''' x y))
| |
| :: = (y ('''S''' ('''K''' '''K''') '''I''' x y))
| |
| :: = (y ('''K''' '''K''' x ('''I''' x) y))
| |
| :: = (y ('''K''' ('''I''' x) y))
| |
| :: = (y ('''I''' x))
| |
| :: = (y x)
| |
| | |
| The combinatory representation, ('''S''' ('''K''' ('''S''' '''I''')) ('''S''' ('''K''' '''K''') '''I''')) is much
| |
| longer than the representation as a lambda term, ''λx''.''λy''.(y x). This is typical. In general, the ''T''[ ] construction may expand a lambda
| |
| term of length ''n'' to a combinatorial term of length
| |
| [[Big O notation|Θ]](3<sup>''n''</sup>) {{Citation needed|date=May 2010}}.
| |
| | |
| ==== Explanation of the ''T''[ ] transformation ====
| |
| | |
| The ''T''[ ] transformation is motivated by a desire to eliminate
| |
| abstraction. Two special cases, rules 3 and 4, are trivial: ''λx''.''x'' is
| |
| clearly equivalent to '''I''', and ''λx''.''E'' is clearly equivalent to
| |
| ('''K''' ''T''[''E'']) if ''x'' does not appear free in ''E''.
| |
| | |
| The first two rules are also simple: Variables convert to themselves,
| |
| and applications, which are allowed in combinatory terms, are
| |
| converted to combinators simply by converting the applicand and the
| |
| argument to combinators.
| |
| | |
| It's rules 5 and 6 that are of interest. Rule 5 simply says that to
| |
| convert a complex abstraction to a combinator, we must first convert
| |
| its body to a combinator, and then eliminate the abstraction. Rule 6
| |
| actually eliminates the abstraction.
| |
| | |
| ''λx''.(''E₁'' ''E₂'') is a function which takes an argument, say ''a'', and
| |
| substitutes it into the lambda term (''E₁'' ''E₂'') in place of ''x'',
| |
| yielding (''E₁'' ''E₂'')[''x'' : = ''a'']. But substituting ''a'' into (''E₁'' ''E₂'') in place
| |
| of ''x'' is just the same as substituting it into both ''E₁'' and ''E₂'', so
| |
| | |
| : (''E₁'' ''E₂'')[''x'' := ''a''] = (''E₁''[''x'' := ''a''] ''E₂''[''x'' := ''a''])
| |
| | |
| : (''λx''.(''E₁'' ''E₂'') ''a'') = ((''λx''.''E₁'' ''a'') (''λx''.''E₂'' ''a''))
| |
| ::::: = ('''S''' ''λx''.''E₁'' ''λx''.''E₂'' ''a'')
| |
| ::::: = (('''S''' ''λx''.''E₁'' ''λx''.''E₂'') ''a'')
| |
| | |
| By extensional equality,
| |
| | |
| : ''λx''.(''E₁'' ''E₂'') = ('''S''' ''λx''.''E₁'' ''λx''.''E₂'')
| |
| | |
| Therefore, to find a combinator equivalent to ''λx''.(''E₁'' ''E₂''), it is
| |
| sufficient to find a combinator equivalent to ('''S''' ''λx''.''E₁'' ''λx''.''E₂''), and
| |
| | |
| : ('''S''' ''T''[''λx''.''E₁''] ''T''[''λx''.''E₂''])
| |
| | |
| evidently fits the bill. ''E₁'' and ''E₂'' each contain strictly fewer
| |
| applications than (''E₁'' ''E₂''), so the recursion must terminate in a lambda
| |
| term with no applications at all—either a variable, or a term of the
| |
| form ''λx''.''E''.
| |
| | |
| === Simplifications of the transformation ===
| |
| ==== η-reduction ====
| |
| | |
| The combinators generated by the ''T''[ ] transformation can be made
| |
| smaller if we take into account the ''η-reduction'' rule:
| |
| | |
| : ''T''[''λx''.(''E'' ''x'')] = ''T''[''E''] (if ''x'' is not free in ''E'')
| |
| | |
| ''λx''.(''E'' x) is the function which takes an argument, ''x'', and
| |
| applies the function ''E'' to it; this is extensionally equal to the
| |
| function ''E'' itself. It is therefore sufficient to convert ''E'' to
| |
| combinatorial form.
| |
| | |
| Taking this simplification into account, the example above becomes:
| |
| | |
| : ''T''[''λx''.''λy''.(''y'' ''x'')]
| |
| : = ...
| |
| : = ('''S''' ('''K''' ('''S''' '''I''')) ''T''[''λx''.('''K''' ''x'')])
| |
| : = ('''S''' ('''K''' ('''S''' '''I''')) '''K''') (by η-reduction)
| |
| | |
| This combinator is equivalent to the earlier, longer one:
| |
| | |
| : ('''S''' ('''K''' ('''S''' '''I''')) '''K''' ''x'' ''y'')
| |
| : = ('''K''' ('''S''' '''I''') ''x'' ('''K''' ''x'') ''y'')
| |
| : = ('''S''' '''I''' ('''K''' ''x'') ''y'')
| |
| : = ('''I''' ''y'' ('''K''' ''x'' ''y''))
| |
| : = (''y'' ('''K''' ''x'' ''y''))
| |
| : = (''y'' ''x'')
| |
| | |
| Similarly, the original version of the ''T''[ ] transformation
| |
| transformed the identity function ''λf''.''λx''.(''f'' ''x'') into ('''S''' ('''S''' ('''K''' '''S''') ('''S''' ('''K''' '''K''') '''I''')) ('''K''' '''I''')). With the η-reduction rule, ''λf''.''λx''.(''f'' ''x'') is
| |
| transformed into '''I'''.
| |
| | |
| ==== One-point basis ====
| |
| | |
| There are one-point bases from which every combinator can be composed extensionally equal to ''any'' lambda term. The simplest example of such a basis is {'''X'''} where:
| |
| | |
| : '''X''' ≡ ''λx''.((x'''S''')'''K''')
| |
| | |
| It is not difficult to verify that:
| |
| : '''X''' ('''X''' ('''X''' '''X''')) =<sup>ηβ</sup> '''K''' and
| |
| : '''X''' ('''X''' ('''X''' ('''X''' '''X'''))) =<sup>ηβ</sup> '''S'''.
| |
| | |
| Since {'''K''', '''S'''} is a basis, it follows that {'''X'''} is a basis too. The [[Iota and Jot|Iota]] programming language uses '''X''' as its sole combinator.
| |
| | |
| Another simple example of a one-point basis is:
| |
| | |
| : '''X'''' ≡ ''λx''.(x '''K''' '''S''' '''K''') with
| |
| : ('''X'''' '''X'''') '''X'''' =<sup>β</sup> '''K''' and
| |
| : '''X'''' ('''X'''' '''X'''') =<sup>β</sup> '''S'''
| |
| | |
| '''X' ''' does not need η contraction in order to produce '''K''' and '''S'''. In fact, there exist infinitely many such bases.<ref>http://www.sciencedirect.com/science/article/pii/S0020019003005416</ref>
| |
| | |
| ==== Combinators B, C ====
| |
| | |
| In addition to '''S''' and '''K''', [[Moses Schönfinkel|Schönfinkel]]'s paper included two combinators which are now called '''B''' and '''C''', with the following reductions:
| |
| | |
| : ('''C''' ''f'' ''x'' ''y'') = (''f'' ''y'' ''x'')
| |
| : ('''B''' ''f'' ''g'' ''x'') = (''f'' (''g'' ''x''))
| |
| | |
| He also explains how they in turn can be expressed using only '''S''' and '''K'''.
| |
| | |
| These combinators are extremely useful when translating predicate logic or lambda calculus into combinator expressions. They were also used by [[Haskell Curry|Curry]], and much later by [[David Turner (computer scientist)|David Turner]], whose name has been associated with their computational use. Using them, we can extend the rules for the transformation as follows:
| |
| | |
| # ''T''[''x''] => ''x''
| |
| # ''T''[(''E₁'' ''E₂'')] => (''T''[''E₁''] ''T''[''E₂''])
| |
| # ''T''[''λx''.''E''] => ('''K''' ''T''[''E'']) (if ''x'' is not free in ''E'')
| |
| # ''T''[''λx''.''x''] => '''I'''
| |
| # ''T''[''λx''.''λy''.''E''] => ''T''<nowiki>[</nowiki>''λx''.''T''<nowiki>[</nowiki>''λy''.''E''<nowiki>]]</nowiki> (if ''x'' is free in ''E'')
| |
| # ''T''[''λx''.(''E₁'' ''E₂'')] => ('''S''' ''T''[''λx''.''E₁''] ''T''[''λx''.''E₂'']) (if ''x'' is free in both ''E₁'' and ''E₂'')
| |
| # ''T''[''λx''.(''E₁'' ''E₂'')] => ('''C''' ''T''[''λx''.''E₁''] ''T''[''E₂'']) (if ''x'' is free in ''E₁'' but not ''E₂'')
| |
| # ''T''[''λx''.(''E₁'' ''E₂'')] => ('''B''' ''T''[''E₁''] ''T''[''λx''.''E₂'']) (if ''x'' is free in ''E₂'' but not ''E₁'')
| |
| | |
| Using '''B''' and '''C''' combinators, the transformation of
| |
| ''λx''.''λy''.(''y'' ''x'') looks like this:
| |
| | |
| : ''T''[''λx''.''λy''.(''y'' ''x'')]
| |
| : = ''T''<nowiki>[</nowiki>''λx''.''T''<nowiki>[</nowiki>''λy''.(''y'' ''x'')<nowiki>]</nowiki><nowiki>]</nowiki>
| |
| : = ''T''[''λx''.('''C''' ''T''[''λy''.''y''] ''x'')] (by rule 7)
| |
| : = ''T''[''λx''.('''C''' '''I''' ''x'')]
| |
| : = ('''C''' '''I''') (η-reduction)
| |
| : = '''C'''<sub>*</sub>(traditional canonical notation : '''X'''<sub>*</sub> = '''X''' '''I''')
| |
| : = '''I''''(traditional canonical notation: '''X'''' = '''C''' '''X''')
| |
| | |
| And indeed, ('''C''' '''I''' ''x'' ''y'') does reduce to (''y'' ''x''):
| |
| | |
| : ('''C''' '''I''' ''x'' ''y'')
| |
| : = ('''I''' ''y'' ''x'')
| |
| : = (''y'' ''x'')
| |
| | |
| The motivation here is that '''B''' and '''C''' are limited versions of '''S'''.
| |
| Whereas '''S''' takes a value and substitutes it into both the applicand and
| |
| its argument before performing the application, '''C''' performs the
| |
| substitution only in the applicand, and '''B''' only in the argument.
| |
| | |
| The modern names for the combinators come from [[Haskell Curry]]'s doctoral thesis of 1930 (see [[B,C,K,W System]]). In [[Moses Schönfinkel|Schönfinkel]]'s original paper, what we now call '''S''', '''K''', '''I''', '''B''' and '''C''' were called '''S''', '''C''', '''I''', '''Z''', and '''T''' respectively.
| |
| | |
| The reduction in combinator size that results from the new transformation rules
| |
| can also be achieved without introducing '''B''' and '''C''', as demonstrated in Section 3.2 of.
| |
| <ref>John Tromp, Binary Lambda Calculus and Combinatory Logic, in ''Randomness And Complexity, from Leibniz To Chaitin'', ed. Cristian S. Calude, World Scientific Publishing Company, October 2008. [http://www.cwi.nl/~tromp/cl/LC.pdf (pdf version)]</ref>
| |
| | |
| ===== CL<sub>K</sub> versus CL<sub>I</sub> calculus =====
| |
| A distinction must be made between the '''CL'''<sub>K</sub> as described in this article and the '''CL'''<sub>I</sub> calculus. The distinction corresponds to that between the λ<sub>K</sub> and the λ<sub>I</sub> calculus. Unlike the λ<sub>K</sub> calculus, the λ<sub>I</sub> calculus restricts abstractions to:
| |
| ::''λx''.''E'' where ''x'' has at least one free occurrence in ''E''.
| |
| As a consequence, combinator '''K''' is not present in the λ<sub>I</sub> calculus nor in the '''CL'''<sub>I</sub> calculus. The constants of '''CL'''<sub>I</sub> are: '''I''', '''B''', '''C''' and '''S''', which form a basis from which all '''CL'''<sub>I</sub> terms can be composed (modulo equality). Every λ<sub>I</sub> term can be converted into an equal '''CL'''<sub>I</sub> combinator according to rules similar to those presented above for the conversion of λ<sub>K</sub> terms into '''CL'''<sub>K</sub> combinators. See chapter 9 in Barendregt (1984).
| |
| | |
| === Reverse conversion ===
| |
| | |
| The conversion ''L''[ ] from combinatorial terms to lambda terms is
| |
| trivial:
| |
| | |
| : ''L''['''I'''] = ''λx''.''x''
| |
| : ''L''['''K'''] = ''λx''.''λy''.''x''
| |
| : ''L''['''C'''] = ''λx''.''λy''.''λz''.(''x'' ''z'' ''y'')
| |
| : ''L''['''B'''] = ''λx''.''λy''.''λz''.(''x'' (''y'' ''z''))
| |
| : ''L''['''S'''] = ''λx''.''λy''.''λz''.(''x'' ''z'' (''y'' ''z''))
| |
| : ''L''[(''E₁'' ''E₂'')] = (''L''[''E₁''] ''L''[''E₂''])
| |
| | |
| Note, however, that this transformation is not the inverse
| |
| transformation of any of the versions of ''T''[ ] that we have seen.
| |
| | |
| == Undecidability of combinatorial calculus ==
| |
| | |
| A [[normal form (abstract rewriting)|normal form]] is any combinatory term in which the primitive combinators that occur, if any, are not applied to enough arguments to be simplified. It is undecidable whether a general combinatory term has a normal form; whether two combinatory terms are equivalent, etc. This is equivalent to the undecidability of the corresponding problems for lambda terms. However, a direct proof is as follows:
| |
| | |
| First, observe that the term
| |
| | |
| : '''Ω''' = ('''S''' '''I''' '''I''' ('''S''' '''I''' '''I'''))
| |
| | |
| has no normal form, because it reduces to itself after three steps, as
| |
| follows:
| |
| | |
| :{{spaces|2}} ('''S''' '''I''' '''I''' ('''S''' '''I''' '''I'''))
| |
| : = ('''I''' ('''S''' '''I''' '''I''') ('''I''' ('''S''' '''I''' '''I''')))
| |
| : = ('''S''' '''I''' '''I''' ('''I''' ('''S''' '''I''' '''I''')))
| |
| : = ('''S''' '''I''' '''I''' ('''S''' '''I''' '''I'''))
| |
| and clearly no other reduction order can make the expression shorter.
| |
| | |
| Now, suppose '''N''' were a combinator for detecting normal forms,
| |
| such that
| |
| | |
| : ('''N''' ''x'') => '''T''', if ''x'' has a normal form
| |
| :{{spaces|12}} '''F''', otherwise.
| |
| | |
| (Where '''T''' and '''F''' represent the conventional [[Church encoding]]s of true and false, ''λx''.''λy''.''x'' and ''λx''.''λy''.''y'', transformed into combinatory logic. The combinatory versions have '''T''' = '''K''' and '''F''' = ('''K''' '''I''').)
| |
| | |
| Now let
| |
| | |
| : ''Z'' = ('''C''' ('''C''' ('''B''' '''N''' ('''S''' '''I''' '''I''')) '''Ω''') '''I''')
| |
| | |
| now consider the term ('''S''' '''I''' '''I''' ''Z''). Does ('''S''' '''I''' '''I''' ''Z'') have a normal
| |
| form? It does if and only if the following do also:
| |
| | |
| :{{spaces|2}} ('''S''' '''I''' '''I''' ''Z'')
| |
| : = ('''I''' ''Z'' ('''I''' ''Z''))
| |
| : = (''Z'' ('''I''' ''Z''))
| |
| : = (''Z'' ''Z'')
| |
| : = ('''C''' ('''C''' ('''B''' '''N''' ('''S''' '''I''' '''I''')) '''Ω''') '''I''' ''Z'') (definition of ''Z'')
| |
| : = ('''C''' ('''B''' '''N''' ('''S''' '''I''' '''I''')) '''Ω''' ''Z'' '''I''')
| |
| : = ('''B''' '''N''' ('''S''' '''I''' '''I''') ''Z'' '''Ω''' '''I''')
| |
| : = ('''N''' ('''S''' '''I''' '''I''' ''Z'') '''Ω''' '''I''')
| |
| Now we need to apply '''N''' to ('''S''' '''I''' '''I''' ''Z'').
| |
| Either ('''S''' '''I''' '''I''' ''Z'') has a normal form, or it does not. If it ''does''
| |
| have a normal form, then the foregoing reduces as follows:
| |
| | |
| :{{spaces|2}} ('''N''' ('''S''' '''I''' '''I''' ''Z'') '''Ω''' '''I''')
| |
| : = ('''K''' '''Ω''' '''I''') (definition of '''N''')
| |
| : = '''Ω'''
| |
| but '''Ω''' does ''not'' have a normal form, so we have a contradiction. But
| |
| if ('''S''' '''I''' '''I''' ''Z'') does ''not'' have a normal form, the foregoing reduces as
| |
| follows:
| |
| | |
| :{{spaces|2}} ('''N''' ('''S''' '''I''' '''I''' ''Z'') '''Ω''' '''I''')
| |
| : = ('''K''' '''I''' '''Ω''' '''I''') (definition of '''N''')
| |
| : = ('''I''' '''I''')
| |
| : = '''I'''
| |
| which means that the normal form of ('''S''' '''I''' '''I''' ''Z'') is simply '''I''', another
| |
| contradiction. Therefore, the hypothetical normal-form combinator '''N'''
| |
| cannot exist.
| |
| | |
| The combinatory logic analogue of [[Rice's theorem]] says that there is no complete nontrivial predicate. A ''predicate'' is a combinator that, when applied, returns either '''T''' or '''F'''. A predicate ''N'' is ''nontrivial'' if there are two arguments ''A'' and ''B'' such that ''NA''='''T''' and ''NB''='''F'''. A combinator ''N'' is ''complete'' if and only if ''NM'' has a normal form for every argument ''M''. The analogue of Rice's theorem then says that every complete predicate is trivial. The proof of this theorem is rather simple.
| |
| | |
| '''Proof:''' By reductio ad absurdum. Suppose there is a complete non trivial predicate, say ''N''.<br />
| |
| Because ''N'' is supposed to be non trivial there are combinators ''A'' and ''B'' such that<br />
| |
| :(''N A'') = '''T''' and
| |
| :(''N B'') = '''F'''.
| |
| | |
| Define NEGATION ≡ ''λx.''(if (''N x'') then ''B'' else ''A'') ≡ ''λx.''((''N x'') ''B'' ''A'')<br />
| |
| Define ABSURDUM ≡ ('''Y''' NEGATION)
| |
| | |
| Fixed point theorem gives: ABSURDUM = (NEGATION ABSURDUM), for<br />
| |
| ABSURDUM ≡ ('''Y''' NEGATION) = (NEGATION ('''Y''' NEGATION)) ≡ (NEGATION ABSURDUM).
| |
| | |
| Because ''N'' is supposed to be complete either:
| |
| # (''N'' ABSURDUM) = '''F''' or
| |
| # (''N'' ABSURDUM) = '''T'''
| |
| | |
| Case 1: '''F''' = (''N'' ABSURDUM) = ''N'' (NEGATION ABSURDUM) = (''N A'') = '''T''', a contradiction.<br />
| |
| Case 2: '''T''' = (''N'' ABSURDUM) = ''N'' (NEGATION ABSURDUM) = (''N B'') = '''F''', again a contradiction.
| |
| | |
| Hence (''N'' ABSURDUM) is neither '''T''' nor '''F''', which contradicts the presupposition that ''N'' would be a complete non trivial predicate. '''QED'''.
| |
| | |
| From this undecidability theorem it immediately follows that there is no complete predicate that can discriminate between terms that have a normal form and terms that do not have a normal form. It also follows that there is '''no''' complete predicate, say EQUAL, such that:
| |
| :(EQUAL ''A B'') = '''T''' if ''A'' = ''B'' and
| |
| :(EQUAL ''A B'') = '''F''' if ''A'' ≠ ''B''.
| |
| If EQUAL would exist, then for all ''A'', ''λx.''(EQUAL ''x A'') would have to be a complete non trivial predicate.
| |
| | |
| == Applications ==
| |
| === Compilation of functional languages ===
| |
| | |
| David Turner used his combinators to implement the [[SASL programming language]].
| |
| | |
| [[Kenneth E. Iverson]] used primitives based on Curry's combinators in his [[J programming language]], a successor to [[APL (programming language)|APL]]. This enabled what Iverson called [[tacit programming]], that is, programming in functional expressions containing no variables, along with powerful tools for working with such programs. It turns out that tacit programming is possible in any APL-like language with user-defined operators <ref>http://portal.acm.org/citation.cfm?id=114065&dl=GUIDE&coll=GUIDE Pure Functions in APL and J</ref>
| |
| <!--
| |
| (Discuss strict vs. [[lazy evaluation]] semantics. Note implications of
| |
| graph reduction implementation for lazy evaluation. Point out
| |
| efficiency problem in lazy semantics: Repeated evaluation of the same
| |
| expression, in, e.g. (square COMPLICATED) => (* COMPLICATED
| |
| COMPLICATED), normally avoided by eager evaluation and call-by-value.
| |
| Discuss benefit of graph reduction in this case: when (square
| |
| COMPLICATED) is evaluated, the representation of COMPLICATED can be
| |
| shared by both branches of the resulting graph for (* COMPLICATED
| |
| COMPLICATED), and evaluated only once.)
| |
| -->
| |
| <!-- Work in [[combinator library]] somehow. -->
| |
| | |
| === Logic ===
| |
| The [[Curry–Howard isomorphism]] implies a connection between logic and programming: every proof of a theorem of [[intuitionistic logic]] corresponds to a reduction of a typed lambda term, and conversely. Moreover, theorems can be identified with function type signatures. Specifically, a typed combinatory logic corresponds to a [[Hilbert-style deduction system|Hilbert system]] in [[proof theory]].
| |
| | |
| The '''K''' and '''S''' combinators correspond to the axioms
| |
| :'''AK''': ''A'' → (''B'' → ''A''),
| |
| :'''AS''': (''A'' → (''B'' → ''C'')) → ((''A'' → ''B'') → (''A'' → ''C'')),
| |
| and function application corresponds to the detachment (modus ponens) rule
| |
| :'''MP''': from ''A'' and ''A'' → ''B'' infer ''B''.
| |
| The calculus consisting of '''AK''', '''AS''', and '''MP''' is complete for the implicational fragment of the intuitionistic logic, which can be seen as follows. Consider the set ''W'' of all deductively closed sets of formulas, ordered by [[inclusion (set theory)|inclusion]]. Then <math>\langle W,\subseteq\rangle</math> is an intuitionistic [[Kripke semantics|Kripke frame]], and we define a model <math>\Vdash</math> in this frame by
| |
| :<math>X\Vdash A\iff A\in X.</math>
| |
| This definition obeys the conditions on satisfaction of →: on one hand, if <math>X\Vdash A\to B</math>, and <math>Y\in W</math> is such that <math>Y\supseteq X</math> and <math>Y\Vdash A</math>, then <math>Y\Vdash B</math> by modus ponens. On the other hand, if <math>X\not\Vdash A\to B</math>, then <math>X,A\not\vdash B</math> by the [[deduction theorem]], thus the deductive closure of <math>X\cup\{A\}</math> is an element <math>Y\in W</math> such that <math>Y\supseteq X</math>, <math>Y\Vdash A</math>, and <math>Y\not\Vdash B</math>.
| |
| | |
| Let ''A'' be any formula which is not provable in the calculus. Then ''A'' does not belong to the deductive closure ''X'' of the empty set, thus <math>X\not\Vdash A</math>, and ''A'' is not intuitionistically valid.
| |
| | |
| ==See also==
| |
| * [[SKI combinator calculus]]
| |
| * [[B,C,K,W system]]
| |
| * [[Fixed point combinator]]
| |
| * [[graph reduction machine]]
| |
| * [[supercombinator]]s
| |
| * [[Lambda calculus]] and [[Cylindric algebra]], other approaches to modelling quantification and eliminating variables
| |
| * ''[[To Mock a Mockingbird]]''
| |
| * [[combinatory categorial grammar]]
| |
| * [[Categorical abstract machine]]
| |
| * [[Applicative computing systems]]
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| | |
| ==Further reading==
| |
| *[[Hendrik Pieter Barendregt]], 1984. ''The Lambda Calculus, Its Syntax and Semantics''. Studies in Logic and the Foundations of Mathematics, Volume 103, North-Holland. ISBN 0-444-87508-5
| |
| *{{cite book
| |
| | last1 = Curry | first1 = Haskell B.
| |
| | authorlink1 = Haskell Curry
| |
| | last2 = Feys | first2 = Robert
| |
| | authorlink2 = Robert Feys
| |
| | title = Combinatory Logic
| |
| | volume = Vol. I
| |
| | year = 1958
| |
| | publisher = North Holland
| |
| | location = Amsterdam
| |
| | isbn = 0-7204-2208-6
| |
| }}
| |
| *{{cite book
| |
| | last1 = Curry | first1 = Haskell B.
| |
| | first2 = J. Roger | last2 = Hindley
| |
| | first3 = Jonathan P. | last3 = Seldin
| |
| | authorlink1 = Haskell Curry
| |
| | authorlink2 = J. Roger Hindley
| |
| | authorlink3 = Jonathan P. Seldin
| |
| | title = Combinatory Logic
| |
| | volume = Vol. II
| |
| | year = 1972
| |
| | publisher = North Holland
| |
| | location = Amsterdam
| |
| | isbn = 0-7204-2208-6
| |
| }}
| |
| * Field, Anthony J. and Peter G. Harrison, 1998. ''Functional Programming''. . Addison-Wesley. ISBN 0-201-19249-7
| |
| *{{cite
| |
| | last1 = Hindley | first1 = J. Roger
| |
| | last2 = Meredith | first2 = David
| |
| | authorlink1 = J. Roger Hindley
| |
| | authorlink2 = David Meredith
| |
| | title = Principal type-schemes and condensed detachment
| |
| | url = http://projecteuclid.org/euclid.jsl/1183743187
| |
| | id = {{MR|1043546}}
| |
| | journal = [[Journal of Symbolic Logic]]
| |
| | volume = 55
| |
| | issue = 1
| |
| | pages = 90–105
| |
| | year = 1990
| |
| }}
| |
| * Hindley, J. R., and Seldin, J. P. (2008) ''[http://www.cambridge.org/catalogue/catalogue.asp?isbn=9780521898850 λ-calculus and Combinators: An Introduction]''. Cambridge Univ. Press.
| |
| * Paulson, Lawrence C., 1995. ''[http://www.cl.cam.ac.uk/Teaching/Lectures/founds-fp/Founds-FP.ps.gz Foundations of Functional Programming.]'' University of Cambridge.
| |
| *<span id="Quine 1960">[[Willard Van Orman Quine|Quine, W. V.]], 1960 "Variables explained away", ''Proceedings of the American Philosophical Society'' '''104''':3:343–347 (June 15, 1960) [http://links.jstor.org/sici?sici=0003-049X%2819600615%29104%3A3%3C343%3AVEA%3E2.0.CO%3B2-W at JSTOR]. Reprinted as Chapter 23 of Quine's ''Selected Logic Papers'' (1966), pp. 227–235</span>
| |
| * [[Moses Schönfinkel]], 1924, "Über die Bausteine der mathematischen Logik," translated as "On the Building Blocks of Mathematical Logic" in ''From Frege to Gödel: a source book in mathematical logic, 1879–1931'', [[Jean van Heijenoort]], ed. Harvard University Press, 1967. ISBN 0-674-32449-8. The article that founded combinatory logic.
| |
| *Sørensen, Morten Heine B. and Paweł Urzyczyn, 1999. ''[http://folli.loria.fr/cds/1999/library/pdf/curry-howard.pdf Lectures on the Curry–Howard Isomorphism.]'' University of Copenhagen and University of Warsaw, 1999.
| |
| * [[Raymond Smullyan|Smullyan, Raymond]], 1985. ''[[To Mock a Mockingbird]]''. Knopf. ISBN 0-394-53491-3. A gentle introduction to combinatory logic, presented as a series of recreational puzzles using bird watching metaphors.
| |
| *--------, 1994. ''Diagonalization and Self-Reference''. Oxford Univ. Press. Chpts. 17-20 are a more formal introduction to combinatory logic, with a special emphasis on fixed point results.
| |
| * Wolfengagen, V.E. ''[http://vew.0catch.com/books/Wolfengagen_CLP-2003-En.djvu Combinatory logic in programming.] Computations with objects through examples and exercises''. -- 2-nd ed. -- M.: "Center JurInfoR" Ltd., 2003. -- x+337 с. ISBN 5-89158-101-9.
| |
| | |
| ==External links==
| |
| *[[Stanford Encyclopedia of Philosophy]]: "[http://plato.stanford.edu/entries/logic-combinatory/ Combinatory Logic]" by Katalin Bimbó.
| |
| *[http://www.sadl.uleth.ca/gsdl/cgi-bin/library?a=p&p=about&c=curry 1920–1931 Curry's block notes.]
| |
| *Keenan, David C. (2001) "[http://dkeenan.com/Lambda/index.htm To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction.]"
| |
| *Rathman, Chris, "[http://www.angelfire.com/tx4/cus/combinator/birds.html Combinator Birds.]" A table distilling much of the essence of Smullyan (1985).
| |
| *[http://cstein.kings.cam.ac.uk/~chris/combinators.html Drag 'n' Drop Combinators.] (Java Applet)
| |
| *[http://www.cwi.nl/~tromp/cl/LC.pdf Binary Lambda Calculus and Combinatory Logic.]
| |
| *[http://code.google.com/p/clache Combinatory logic reduction web server]
| |
| | |
| [[Category:Lambda calculus]]
| |
| [[Category:Logic in computer science]]
| |
| [[Category:Combinatory logic|*]]
| |