« Lambda counting » : différence entre les versions
Ligne 12 : | Ligne 12 : | ||
This question has some known results for Turing machines and cellular automata. Some of them will be given in section ??. |
This question has some known results for Turing machines and cellular automata. Some of them will be given in section ??. |
||
In this introduction we consider that this notion of probabilty is, at least intuitively, sufficiently clear but, of course, this will have to be made precise. |
|||
⚫ | |||
We will consider this question for functional programming languages. For this kind of languages we can consider various properties. Some concern the structural of the program, some concern its behaviour. |
|||
The simplest such language is the lambda calculus. |
|||
⚫ | |||
In this introduction we consider that |
|||
This paper proves some highly non trivial results of this form. In particular we show that almost every closed lambda term begins with "many" <math>\lambda</math> (the precise meaning of this is given in theorem ??), that these <math>\lambda</math> bound "many" occurences of the corresponding variables theorem ??) and that, given any fixed closed term, almost ''no'' <math>\lambda</math>-term has this term as a sub-term. |
This paper proves some highly non trivial results of this form. In particular we show that almost every closed lambda term begins with "many" <math>\lambda</math> (the precise meaning of this is given in theorem ??), that these <math>\lambda</math> bound "many" occurences of the corresponding variables theorem ??) and that, given any fixed closed term, almost ''no'' <math>\lambda</math>-term has this term as a sub-term. |
||
Our original motivation was to consider the property of being terminating. Is a random term strongly normalizable (SN for short)? This question is, at present, unsolved and the experiments we have done do not give an idea of the result. It is known that being SN is an undecidable question and it is thus not easy to the number of SN terms of big size. It is clear that having <math>(\delta \ \delta)</math> as a sub-term is a sufficient (but not necessary) condition |
Our original motivation was to consider the property of being terminating. Is a random term strongly normalizable (SN for short)? This question is, at present, unsolved and the experiments we have done do not even give an idea of what the result should be. It is known that being SN is an undecidable question and it is thus not easy to count the number of SN terms of big size. It is clear that having <math>(\delta \ \delta)</math> as a sub-term is a sufficient (but not necessary) condition for being non SN but as the experiments have shown (and as we have proved) almost no terms contains <math>(\delta \ \delta)</math> and this is thus useless to have a rsult for non SN. On the opposite direction, it is known that, if a term t is not SN, then a pattern "looking like" <math>(\delta \ \delta)</math> (the precise meaning will be given in sectioon ??) must appear in t but the experiments seem to show that almost every term possesses this pattern (actually, we have not bee |
||
== Lambert function, Catalan and Motzkin numbers == |
== Lambert function, Catalan and Motzkin numbers == |
Version du 21 octobre 2008 à 08:16
Introduction
what kind of properties : structural (for functional programs), behaviour (SN, weakly normalizable, ...
references to known results on : turing machines, cellular automata
we concentrate on combinatory logic, lambda calculus)
This paper adresses the following question. Having a (theoritical) programming language and a property of programs in that language. What is the probability that a random program satisfies the given property ? In particular, is it the case that almost every random program satisfies the desired property i.e. the probability is 1 ? This question has some known results for Turing machines and cellular automata. Some of them will be given in section ??.
In this introduction we consider that this notion of probabilty is, at least intuitively, sufficiently clear but, of course, this will have to be made precise.
We will consider this question for functional programming languages. For this kind of languages we can consider various properties. Some concern the structural of the program, some concern its behaviour.
The simplest such language is the lambda calculus. Some experiments have been done for it (see for example ...) which clearly indicates that, for example, almost every closed lambda term begins with a but, as far as we know, there is no proved result of this form.
This paper proves some highly non trivial results of this form. In particular we show that almost every closed lambda term begins with "many" (the precise meaning of this is given in theorem ??), that these bound "many" occurences of the corresponding variables theorem ??) and that, given any fixed closed term, almost no -term has this term as a sub-term.
Our original motivation was to consider the property of being terminating. Is a random term strongly normalizable (SN for short)? This question is, at present, unsolved and the experiments we have done do not even give an idea of what the result should be. It is known that being SN is an undecidable question and it is thus not easy to count the number of SN terms of big size. It is clear that having as a sub-term is a sufficient (but not necessary) condition for being non SN but as the experiments have shown (and as we have proved) almost no terms contains and this is thus useless to have a rsult for non SN. On the opposite direction, it is known that, if a term t is not SN, then a pattern "looking like" (the precise meaning will be given in sectioon ??) must appear in t but the experiments seem to show that almost every term possesses this pattern (actually, we have not bee
Lambert function, Catalan and Motzkin numbers
Catalan numbers
- : Catalan numbers
Usual equivalent: which is obtained using Strirling formula. However, using stirling series: , we get that for we have
Thus, using this and , we have:
for all but also for .
Motzkin numbers
Let us define the number of unary-binary trees with inner nodes and leafs. We get
Then, by summing we define the number of unary-binary trees with inner nodes and give an equivalent:
Lambert W function
The Lambert function is defined by the equation which has a unique solution in .
For , we have which implies that near . To prove this, it is enough to remark that
This is not precise enough for our purpose. Using one step of the Newton method from , we can find a better upper bound for because is increasing and convex. This gives:
Indeed, if we define , we have and therefore, newton's method from gives a point at position:
Finally, we show that for , we have:
Indeed, for , we have , which implies and therefore .
combinatory logic
Basically the paper already written by Marek
+ the following
As we will see in section ??, theorem ?? does not holds for the Lambda calculus. This may be surprising since there are translations between these systems which respect many properties (for exemple the one of being terminating). However these translations do not preserve the size.
The translation T from combinatory logic to lambda calculus is linear, i.e. there is a constant k such that, for all terms, but the translation T' in the other direction is not linear. As far as we know, there is no known bound on the size of T'(t) but it is not difficult to find exemples where size(T'(t)) is of order .
The point is that T' has to code the binding in some way and this takes place. It will be interesting to compare the size of T'(t) with the one of t using other notion of size than the usual one. See section ?? for some complement.
Generality on lambda calculus
definition
The set of lambda terms (or, simply, terms) is defined by the following grammar
To be able to define the notion of a random term we
have to define a distribution law on . There are many
possibilities for that. We choose here the simplest one. Note that this is the one for which, at least at present, we are
able to prove some results. It is based on densities. For that we
first have to define the size of a term.
The usual definition is the following.
definition
The size (denoted as ) of a term is defined by the following rules.
- if is a variable.
-
-
In the rest of the paper we will use another definition (denoted
as ) which is similar but gives simpler computations.
We believe (but we have not yet checked the details) that, with
we would have similar results. The
computation, with , of the upper and lower
bounds of the number of terms of size will be done
in section ??
definition
The size (denoted as or, more simply ) of a term is defined by the following rules.
- if is a variable.
-
-
These definitions of the size are, for the implementation point of
view, not realistic because, in case a term has a lot of distinct
variables, it is not realistic to use a single bit to code them.
The usual way to implement this coding is to replace the names of
variables by their so called de Bruijn indices: a variable is
replaced by the number of that occur, on the
path from the variable to the root, between the variable and the
that binds it. Note that, in this case,
different occurrences of the same variable may be represented by
different indices.
Choosing the way we code these de Bruijn indices gives different other ways of defining the size of a term. This can be done in the following ways
- Use unary notation, i.e. the size of the index simply is itself
- Use optimal binary notation, i.e. the size of the index is i.e. the logarithm of in base 2.
- Use uniform binary notation, i.e. the size of an index is the logarithm, in base 2, of the number of leaves of the term.
Remark
See section ?? for a discusion about these different size.
definition
Let be an integer. We denote by the set of terms of size n.
definition
Let A be a set of terms.
1) We denote by the cardinality of A.
2) We denote by the limit, for n going to , of .
Remark
Note that d is not exactly a measure since is undefined if the previous limit does not exist
definition
Let P be a property of terms. We will say that almost every term satisfies P (this will be also stated as P holds a.e.) if
generating functions
this does not work (by now) because radius of convergence 0
no known results for the number of terms of size n (denoted )
our results
(the proof of result of section k needs the result of section (k-1))
Upper and lower bounds for
For the lower bound, we will first count the number of lambda-terms of size starting with lambdas and having no other lambda below. This means that the lower part of the term is a binary tree of size with possibility for each leaf. Therefore we have:
And therefore, for , using our lower bound for and , we get:
Now, for fixed, we define (so ) and look for the maximum of this function. We have . Thus, is equivalent to . The Lambert function begin increasing this means that is equivalent to . Therefore, reaches a maximum for .
This means that reaches its maximum for fixed when is near to which is likely not to be an integer. However, there are at least integer between and . Indeed, using our inequalities on Lambert W function, we have:
Thus, we get the following lowerbound for :
To simplify, using the fact that and taking large enough, we have the following lowerbound:
We now compute an upper bound for the number of lambda-terms of size with exactly lambdas (that is with leaves using the Motzkin numbers and allowing any lambda to bind any variable (regardless of the real scope):
If we sum this for all possible and get an upper bound of using Lambert function as for the lower bound, we get the following upper bound for :
The ration between our upper bound and lower bound is equivalent to (NEEDS FURTHER CHECKING):
upper and lower bounds for number of lambdas in a term of size n
Jakub's trik : at least 1 lambda in head position
at least lambdas in head position and number of lambdas in one path
Remark: (may be 4) can be done directly without 3))
each of the head lambdas really bind "many" occurrences of the variable
every fixed closed term (including the identity !) does not appear in a random term (in fact we have much more than that)
comment : so different situation in combinatory logic and lambda calculus ; the coding uses a big size so need to count variables in a different way
Experiments
results of the experiments we have done
some experiments that have to be done : e.g. density of terms having or big Omega pattern ...
to be done
Upper and lower bounds for with other size for variables especially one, binary with fixed size
Open questions and Future work
.....