% Filename: Lambda.tex % Author: Alan Jeffrey % Last modified: 11 May 1990 % (license changed to LPPL, need for ltugboat removed: 6 Aug 2013) % % Copyright 1990-2013 Alan Jeffrey. % This file is part of the lambda-lists package. % % This work may be distributed and/or modified under the % conditions of the LaTeX Project Public License, either version 1.3 % of this license or (at your option) any later version. % The latest version of this license is in % http://www.latex-project.org/lppl.txt % and version 1.3 or later is part of all distributions of LaTeX % version 2003/12/01 or later. % % A keyboard check: % % @ # $ % ^ & * ~ at hash dollar percent caret ampersand asterisk tilde % : ; , . colon semicolon comma period % ? ! question-mark exclamation-mark % " ' ` double-quote apostrophe back-quote % ( ) { } [ ] parentheses braces square-brackets % - + = / \ minus plus equals forward-slash backslash % _ | < > underscore vertical-bar less-than greater-than % \documentstyle[lambda]{article} % This document defines a whole load of extra commands, some of which % over-ride how LaTeX normally lays things out. For example, ~ is % redefined to give a hairspace in math mode. This whole document % should probably be put in a group to stop it getting in the way % of other articles' macros. \title{Lists in \TeX's Mouth} \author{Alan Jeffrey} \makeatletter % The mathcodes for the letters A, ..., Z, a, ..., z are changed to % generate text italic rather than math italic by default. This makes % multi-letter names look neater. The mathcode for character 'c' % is set to "7000 (variable family) + "400 (text italic) + c. % % This neat bit of code is due to Mike Spivey. \def\@setmcodes#1#2#3{{\count0=#1 \count1=#3 \loop \global\mathcode\count0=\count1 \ifnum \count0<#2 \advance\count0 by1 \advance\count1 by1 \repeat}} \@setmcodes{`A}{`Z}{"7441} \@setmcodes{`a}{`z}{"7461} \def\Number#1{\csname Number-#1\endcsname} \def\Label#1{\csname Label-#1\endcsname} \newcount\Lastnum \def\Forward#1% {\global\advance\Lastnum by 1 \csnameafter\xdef{Number-#1}% {\the\Lastnum}% \csnameafter\xdef{Label-\the\Lastnum}% {\@currentlabel}} \def\csnameafter#1#2% {\expandafter#1\csname#2\endcsname} \def\Bylist#1% {\Map\Label {\Insertsort\Lessthan {\Map\Number{#1}}}} \def\By{\Show\Bylist} \let\bindspace=~ \def~{\ifmmode \, \else \bindspace \fi} \def\start#1{\lefteqn{#1}\quad\\} \def\nil{[\,\,]} \newtheorem{fact}{Fact} \def\thefact{\@roman\c@fact} \def\cstok#1{\leavevmode\thinspace\hbox{\vrule\vtop{\vbox{\hrule\kern1pt \hbox{\vphantom{\tt/}\thinspace{\tt#1}\thinspace}}% \kern1pt\hrule}\vrule}\thinspace} \begingroup \catcode `|=0 \catcode `[= 1 \catcode`]=2 \catcode `\{=12 \catcode `\}=12 \catcode`\\=12 |gdef|@xTeXcode#1\end{TeXcode}[#1|end[TeXcode]] |endgroup \def\TeXcode {\@verbatim \smallskip\hrule\medskip \frenchspacing\@vobeyspaces \@xTeXcode} \def\endTeXcode {\medskip\hrule\smallskip\endtrivlist} \makeatother \begin{document} \maketitle \section{Why lists?} Originally, I wanted lists in \TeX\ for a paper I was writing which contained a lot of facts. \begin{fact} \Forward{Fac-cows} Cows have four legs. \end{fact} \begin{fact} \Forward{Fac-people} People have two legs. \end{fact} \begin{fact} \Forward{Fac-yawn} Lots of facts in a row can be dull. \end{fact} These are generated with commands like \begin{verbatim} \begin{fact} \Forward{Fac-yawn} Lots of facts in a row can be dull. \end{fact} \end{verbatim} I can then refer to these facts by saying \begin{verbatim} \By[Fac-yawn,Fac-cows,Fac-people] \end{verbatim} to get \By[Fac-yawn,Fac-cows,Fac-people]. And as if by magic, the facts come out sorted, rather than in the jumbled order I typed them. This is very useful, as I can reorganize my document to my heart's content, and not have to worry about getting my facts straight. Originally I tried programming this sorting routine in \TeX's list macros, from Appendix~D of \textsl{The \TeX{}book}, but I soon ran into trouble. The problem is that all the Appendix~D macros work by assigning values to macros. For example: \begin{verbatim} \concatenate\foo=\bar\baz \end{verbatim} expands out to \begin{verbatim} \ta=\expandafter{\bar} \tb=\expandafter{\baz} \edef\foo{\the\ta\the\tb} \end{verbatim} which assigns the macro \verb|\foo| the contents of \verb|\bar| followed by the contents of \verb|\baz|. Programming sorting routines (which are usually recursive) in terms of these lists became rather painful, as I was constantly having to watch out for local variables, worrying about what happened if a local variable had the same name as a global one, and generally having a hard time. Then I had one of those ``flash of light'' experiences --- ``You can do lambda-calculus in \TeX,'' I thought, and since you can do lists directly in lambda calculus, you should be able to do lists straightforwardly in \TeX. And so you can. Well, fairly straightforwardly anyway. So I went and did a bit of mathematics, and derived the \TeX\ macros you see here. They were formally verified, and worked first time (modulo typing errors, of which there were two). \section{\TeX's mouth and \TeX's stomach} \TeX's programming facilities come in two forms --- there are \TeX's {\em macros\/} which are expanded in its mouth, and some additional {\em assignment\/} operations like \verb|\def| which take place in the stomach. \TeX\ can often spring surprises on you as exactly what gets evaluated where. For example, in \LaTeX\ I can put down a label by saying \verb|\label{Here}|. \label{Here} Then I can refer back to that label by saying \verb|Section~\ref{Here}|, which produces Section~\ref{Here}. Unfortunately, \verb|\ref{Here}| does {\em not\/} expand out to {\tt\ref{Here}}! Instead, it expands out to: \begin{verbatim} \edef\@tempa{\@nameuse{r@Here}} \expandafter\@car\@tempa\@nil\null \end{verbatim} This means that I can't say \begin{verbatim} \ifnum\ref{Here}<4 Hello\fi \end{verbatim} and hope that this will expand out to Hello. Instead I get an error message. Which is rather a pity, as \TeX's mouth is quite a powerful programming language (as powerful as a Turing Machine in fact). \section{Functions} A {\em function\/} is a mathematical object that takes in an argument (which could well be another function) and returns some other mathematical object. For example the function $Not$ takes in a boolean and returns its complement. I'll write function application without brackets, so $Not~b$ is the boolean complement of $b$. Function application binds to the left, so $f~a~b$ is $(f~a)~b$ rather than $f~(a~b)$. For example, $Or~a~b$ is the boolean or of $a$ and $b$, and $Or~True$ is a perfectly good function that takes in a boolean and returns $True$. The obvious equivalents of functions in \TeX\ are macros --- if I define a function $Foo$ to be: \begin{eqnarray*} Foo~x & = & True \end{eqnarray*} then it can be translated into \TeX\ as: \begin{verbatim} \def\Foo#1{\True} \end{verbatim} So where $Foo$ is a function that takes in one argument, \verb|\Foo| is a macro that takes in one parameter. Nothing has changed except the jargon and the font. \TeX\ macros can even be partially applied, for example if we defined: \begin{eqnarray*} Baz & = & Or~True \end{eqnarray*} then the \TeX\ equivalent would be \begin{verbatim} \def\Baz{\Or\True} \end{verbatim} Once \verb|\Baz| is expanded, it will expect to be given a parameter, but when we are defining things, we can go around partially applying them all we like. Here, I'm using $=$ without formally defining it, which is rather naughty. If I say $x = y$, this means ``given enough parameters, $x$ and $y$ will eventually expand out to the same thing.'' For example $Foo = Baz$, because for any $x$, \begin{eqnarray*} \start{Foo~x} & = & True \\ & = & Or~True~x \\ & = & Baz~x \end{eqnarray*} Normally, functions have to {respect equality\/} which means that: \begin{itemize} \item if $x = y$ then $f~x = f~y$, and \item if $x$ respects equality, then $f~x$ respects equality. \end{itemize} However, some \TeX\ control sequences don't obey this. For example, \verb|\string\Foo| and \verb|\string\Baz| are different, even though $Foo = Baz$. Hence $string$ doesn't respect equality. Unless otherwise stated, we won't assume functions respect equality, although all the functions defined here do. All of our functions have capital letters, so that their \TeX\ equivalents (\verb|\Not|, \verb|\Or| and so on) don't clash with standard \TeX\ or \LaTeX\ macros. \subsection{Identity} The simplest function is the {\em identity\/} function, called $Identity$ funnily enough, which is defined: \begin{eqnarray*} Identity~x & = & \Identity{x} \end{eqnarray*} This, it must be admitted, is a pretty dull function, but it's a useful basic combinator. It can be implemented in \TeX\ quite simply. \begin{TeXcode} \def\Identity#1{#1} \end{TeXcode} The rules around this definition mean that it is actually part of \verb|Lambda.sty| and not just another example. \subsection{Error} Whereas $Identity$ does nothing in a fairly pleasant sort of way, $Error$ does nothing in a particularly brutal and harsh fashion. Mathematically, $Error$ is the function that destroys everything else in front of it. It is often written as $\perp$. \begin{eqnarray*} Error~x & = & Error \end{eqnarray*} In practice, destroying the entire document when we hit one error is a bit much, so we'll just print out an error message. The user can carry on past an error at their own risk, as the code will no longer be formally verified. \begin{TeXcode} \def\Error {\errmessage{Abandon verification all ye who enter here}} \end{TeXcode} Maybe this function ought to return a more useful error message \ldots \subsection{First and Second} Two other basic functions are $First$ and $Second$, both of which take in two arguments, and do the obvious thing. They are defined: \begin{eqnarray*} First~x~y & = & x \\ Second~x~y & = & y \end{eqnarray*} We could, in fact, define $Second$ in terms of $Identity$ and $First$. For any $x$ and $y$, \begin{eqnarray*} \start{First~Identity~x~y} & = & Identity~y \\ & = & y \\ & = & Second~x~y \end{eqnarray*} So $First~Identity = Second$. This means that anywhere in our \TeX\ code we have \verb|\First\Identity| we could replace it by \verb|\Second|. This is perhaps not the most astonishing \TeX\ fact known to humanity, but this sort of proof did enable more complex bits of \TeX\ to be verified before they were run. The \TeX\ definitions of \verb|\First| and \verb|\Second| are pretty obvious. \begin{TeXcode} \def\First#1#2{#1} \def\Second#1#2{#2} \end{TeXcode} Note that in \TeX\, \verb|\First\foo\bar| expands out to \verb|\foo| {\em without\/} expanding out \verb|\bar|. This is very useful, as we can write macros that would take forever and a day to run if they expanded all their arguments, but which actually terminate quite quickly. This is called {\em lazy evaluation\/} by the functional programming community. \subsection{Compose} Given two functions $f$ and $g$ we would like to be able to {\em compose\/} them to produce a function that first applies $g$ then applies $f$. Normally, this is written as $f \circ g$, but unfortunately \TeX\ doesn't have infix functions, so we'll have to write it $Compose~f~g$. \begin{eqnarray*} Compose~f~g~x & = & f~(g~x) \end{eqnarray*} >From this definition, we can deduce that $Compose$ is associative: \begin{eqnarray*} \start{Compose~(Compose~f~g)~h} & = & Compose~f~(Compose~g~h) \end{eqnarray*} and $Identity$ is the left unit of $Compose$: \begin{eqnarray*} Compose~Identity~f & = & f \end{eqnarray*} The reader may wonder why $Identity$ is called a {\em left\/} unit even though it occurs on the right of the $Compose$ --- this is a side-effect of using prefix notations where infix is more normal. The infix version of this equation is: \begin{eqnarray*} Identity \circ f & = & f \end{eqnarray*} so $Identity$ is indeed on the left of the composition. $Compose$ can be implemented in \TeX\ as \begin{TeXcode} \def\Compose#1#2#3{#1{#2{#3}}} \end{TeXcode} \subsection{Twiddle} Yet another useful little function is $Twiddle$, which takes in a function and reverses the order that function takes its (first two) arguments. \begin{eqnarray*} Twiddle~f~x~y & = & f~y~x \end{eqnarray*} Again, there aren't many immediate uses for such a function, but it'll come in handy later on. It satisfies the properties \begin{eqnarray*} Twiddle~First & = & Second \\ Twiddle~Second & = & First \\ Compose~Twiddle~Twiddle & = & Identity \end{eqnarray*} Its \TeX\ equivalent is \begin{TeXcode} \def\Twiddle#1#2#3{#1{#3}{#2}} \end{TeXcode} This function is called ``twiddle'' because it is sometimes written $\widetilde f$ (and $\sim$ is pronounced ``twiddle''). It also twiddles its arguments around, which is quite nice if your sense of humour runs to appalling puns. \section{Booleans} As we're trying to program a sorting routine, it would be nice to be able to define orderings on things, and to do this we need some representation of boolean variables. Unfortunately \TeX\ doesn't have a type for booleans, so we'll have to invent our own. We'll implement a boolean as a function $b$ of the form \begin{eqnarray*} b~x~y & = & \left\{ \begin{array}{ll} x & \mbox{if $b$ is true} \\ y & \mbox{otherwise} \end{array} \right. \end{eqnarray*} More formally, a boolean $b$ is a function which respects equality, such that for all $f$, $g$ and $z$: \begin{eqnarray*} b~f~g~z & = & b~(f~z)~(g~z) \end{eqnarray*} and for all $f$ and $g$ which respect equality, \begin{eqnarray*} b~(f~b)~(g~b) & = & b~(f~First)~(g~Second) \end{eqnarray*} All the functions in this section satisfy these properties. Surprisingly enough, so does $Error$, which is quite useful, as it allows us to reason about booleans which ``go wrong''. \subsection{True, False and Not} Since we are implementing booleans as functions, we already have the definitions of $True$, $False$ and $Not$. \begin{eqnarray*} True & = & First \\ False & = & Second \\ Not & = & Twiddle \end{eqnarray*} So for free we get the following results: \begin{eqnarray*} Not~True & = & False \\ Not~False & = & True \\ Compose~Not~Not & = & Identity \end{eqnarray*} The \TeX\ implementation is not exactly difficult: \begin{TeXcode} \let\True=\First \let\False=\Second \let\Not=\Twiddle \end{TeXcode} \subsection{And and Or} The definitions of $And$ and $Or$ are: \begin{eqnarray*} And~a~b & = & \left\{ \begin{array}{ll} b & \mbox{if $a$ is true} \\ False & \mbox{otherwise} \end{array} \right. \\ Or~a~b & = & \left\{ \begin{array}{ll} True & \mbox{if $a$ is true} \\ b & \mbox{otherwise} \end{array} \right. \end{eqnarray*} With our definition of what a boolean is, this is just the same as \begin{eqnarray*} And~a~b & = & a~b~False \\ Or~a~b & = & a~True~b \end{eqnarray*} >From these conditions, we can show that $And$ is associative, and has left unit $True$ and left zeros $False$ and $Error$: \begin{eqnarray*} And~(And~a~b)~c & = & And~a~(And~b~c) \\ And~True~b & = & b \\ And~False~b & = & False \\ And~Error~b & = & Error \end{eqnarray*} $Or$ is associative, has left unit $False$ and left zeros $True$ and $Error$: \begin{eqnarray*} Or~(Or~a~b)~c & = & Or~a~(Or~b~c) \\ Or~False~b & = & b \\ Or~True~b & = & True \\ Or~Error~b & = & Error \end{eqnarray*} De~Morgan's laws hold: \begin{eqnarray*} Not~(And~a~b) & = & Or~(Not~a)~(Not~b) \\ Not~(Or~a~b) & = & And~(Not~a)~(Not~b) \end{eqnarray*} and $And$ and $Or$ left-distribute through one another: \begin{eqnarray*} Or~a~(And~b~c) & = & And~(Or~a~b)~(Or~a~c) \\ And~a~(Or~b~c) & = & Or~(And~a~b)~(And~a~c) \end{eqnarray*} $And$ and $Or$ are {\em not\/} commutative, though. For example, \begin{eqnarray*} \start{Or~True~Error} & = & True~True~Error \\ & = & True \end{eqnarray*} but \begin{eqnarray*} \start{Or~Error~True} & = & Error~True~True \\ & = & Error \end{eqnarray*} This is actually quite useful since there are some booleans that need to return an error occasionally. If $a$ is $True$ when $b$ is safe (i.e.\ doesn't become $Error$) and is $False$ otherwise, we can say $Or~a~b$ and know we're not going to get an error. This is handy for things like checking for division by zero, or trying to get the first element of an empty list. Similarly, because of the possibility of $Error$, $And$ and $Or$ don't right-distribute through each other, as \begin{eqnarray*} \start{Or~(And~False~Error)~True} & \ne & And~(Or~False~True)~(Or~Error~True) \end{eqnarray*} As errors shouldn't crop up, this needn't worry us too much. \begin{TeXcode} \def\And#1#2{#1{#2}\False} \def\Or#1#2{#1\True{#2}} \end{TeXcode} \subsection{Lift} Quite a lot of the time we won't be dealing with booleans, but with {\em predicates}, which are just functions that return a boolean. For example, the predicate $Lessthan$ is defined below so that $Lessthan~i~j$ is true whenever $i