# Fairouz Kamareddine

Type theory was invented at the begining of the XX century with the purpose of eliminating the paradoxes which come from the application of the function to itself. The Lambda Calculus was developed (by Church) around 1930 as a theory of functions. In 1940, Church added types to his Lambda Calculus. This types were simple, which means they were never constructed using a binder (like Lambda). So, we have terms like $\lambda_{x:T}.B$ (which are constructed with the binder Lambda), but there are no binders which we can use to construct types. Despite the influence of Church's Lambda calculus, its limitation led to the creation of many typed theories in the second half of the XX century. In this calculi, the types are constructed with binders. In most of these calculi we find two binders: the $\lambda$ (to construct terms) and the $\Pi$ (or $\forall$, to construct types). These two binders allow us to distinguish functions (which we construct with $\lambda$) and types (which we construct with $\Pi$). Moreover, in these calculi we allow $\beta$-reduction, but not $\Pi$-reduction. In other words, in these calculi we have the rule:
$(\lambda_{x:A}.B)C \rightarrow B[x:=C]$
But not the rule:
$(\Pi_{x:A}.B)C \rightarrow B[x:=C]$
In particular, when $b$ has the type $B$, we give to $(\lambda_{x:A}.b) C$ the type $B[x:=C]$ instead of $(\Pi_{x:A}.B) C$. There are some powerfull extensions of type theory which give $\Pi$ the same behaviour as $\lambda$ (for example, in Automath, and in the programming language Henk of Simon Peyton Jones, etc.). This leads us to ask the question: Why distinguish between $\lambda$ and $\Pi$ when systems like Automath showed us that it is more advantageous to treat types exactly like terms? In this talk, I describe a system where the two binders are identified and show that the system has all the properties that we expect from a type system except for unicity of types, but I also show that the loss of unicity of types is not serious because there is an isomorphism between typing using two binders and typing using a single one. Moreover, I show that all the different types of the same term follow the same pattern.