{'fraction_non_alphanumeric': 0.0377806286080821, 'fraction_numerical': 0.00295060936497755, 'mean_word_length': 4.082477587612062, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 3, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Formalization in Constructive Type Theory of the Standardization Theorem for the Lambda Calculus using Multiple Substitution

We present a full formalization in Martin-L\"of's Constructive Type Theory of the Standardization Theorem for the Lambda Calculus using first-order syntax with one sort of names for both free and bound variables and Stoughton's multiple substitution. Our formalization is based on a proof by Ryo Kashima, in which a notion of beta-reducibility with a standard sequence is captured by an inductive relation. The proof uses only structural induction over the syntax and the relations defined, which is possible due to the specific formulation of substitution that we employ. The whole development has been machine-checked using the system Agda.


Introduction
In [3] a formalization of the Lambda Calculus in Martin-Löf's Constructive Type Theory is presented, which uses first-order syntax with one sort of names for both free and bound variables that does not identify α-convertible terms, and a multiple substitution operation introduced by Stoughton in [11]. The approach enables the authors to prove in a completely formal and quite elegant way significant results about the metatheory of the Lambda Calculus, namely the Church-Rosser Theorem and Subject Reduction for the simply typed Lambda Calculusà la Curry. The authors developed a library [2] with definitions and lemmas for implementing and manipulating substitutions that was key for achieving the mentioned results, in particular by using only simple standard methods of structural induction on terms and reduction relations.
In the present work we extend the above mentioned metatheoretical study by proving the Standardization Theorem for β -reduction, which we further use to prove that the leftmost-outermost reduction strategy always finds the normal form of a term provided that it exists. The Standardization Theorem is a well-known result in the Lambda Calculus that was first proved by Curry and Feys in [5]. It states that if a term M β -reduces to a term N, then there exists a standard β -reduction sequence from M to N. A reduction sequence is considered standard if successive redexes are contracted from left to right (regarding the linear syntax) possibly with some jumps.
The proof hereby formalized is the one given by Ryo Kashima in [8] where the notion of β -reducibility with a standard sequence is captured by an inductive relation in very much the same way as minimal complete developments are captured by the so-called parallel reduction relation in e.g. Tait and Martin-Löf's method for proving the Church-Rosser theorem. This allows for an elegant inductive development as opposed to basing the proofs on notions like residuals and finite developments as in the classical proofs by Curry-Feys and Barendregt [5,1].
All the definitions and proofs that appear in this article have been machine-checked with the system Agda [10]. In the subsequent text we will mix Agda code and (informal) proofs in English with a considerable level of detail so that they serve for clarifying their formalization. The complete code is available at https://github.com/mcopes73/standardization-agda.
In section 2 we present the basic concepts of the Lambda Calculus, together with some definitions and results from the library produced in [3] on which our work is based, as well as extensions thereof. In section 3 we present the proof of the Standardization Theorem. In section 4 we present the proof of the Leftmost Reduction Theorem for β -reduction. In section 5 we compare our development with other similar efforts in the literature, and present our overall conclusions.

Preliminaries
In what follows we will introduce the main definitions and results in [3,2] that are previous to this work and are used in our formalization. We present the definitions directly using Agda code along with informal explanations, while the proofs are written in English to ease their reading. A certain degree of familiarity with the Agda syntax or at least with that of functional languages like Haskell is assumed.
We shall start by defining λ -terms using the same set of names for both bound and free variables. We use natural numbers to name variables for sake of concreteness.
Agda is pretty liberal with regard to the naming of functions and the positions of their arguments. Notice the notation for declaring the infix application constructor, i.e. _·_. This underscore notation is extended to mixfix operators.
The classical notions of free and fresh (not free) variable in a term, which are denoted by * and # respectively, are defined as binary relations between variables and terms in the usual way (we omit the definitions for reasons of space): Substitutions are identity-almost-everywhere functions associating a term to every variable. We can generate every concrete substitution by starting up from the empty substitution ι that maps each variable to itself as a term, and employing the update operation ≺+, such that if σ is a substitution, then σ ≺+(x, M) is the substitution equal to σ everywhere except at x, where it yields M: Notice that in the definition of ≺+ we use the with construct, which allows us to perform pattern matching on the result of evaluating the expression x ? = y. This expression decides the equality between the variables x and y and has type Dec ≡, whose constructors are yes and no applied to the corresponding proof objects.
In general, we shall consider properties concerning the substitutions for the free variables of a term M, i.e. their restrictions to such variables. The type of restrictions R is defined as: R = Σ × Λ, and we note in the informal language such a restriction as σ M. This means that we are restricting the substitution σ to the free variables of M only. We will also use the following notion: x # (σ M), which stands for x fresh in the σ -value of every free variable of M: The application of substitution σ to the term M is noted M • σ , and it is defined by structural recursion on M. The fact that structural recursion is sufficient for stating this very concrete definition is a (very welcome) non-trivial consequence of the employment of multiple substitutions.
Notice the last line of the definition: when performing a substitution over an abstraction, the bound variable x is always replaced with a new one. This new variable y is obtained by means of a choice function χ, such that χ(σ , M) # (σ M). In this way, y does not capture any of the names introduced into its scope by effect of the substitution 1 . When reasoning with substitutions, this uniform renaming of bound variables allows us to avoid case analyses; it also has other nice consequences, to be noticed shortly. For the sake of readability, we define the single substitution of a term N for a variable x in M with the traditional notation M[x := N]. Alpha-conversion (∼ α ) is defined as the following inductive binary relation on terms: Arguments to a function declared between braces { } are optional and in subsequent applications of the function in question they are inferred by the type-checker. The first two constructors above implement the classical rules for variables and application. The last constructor states that two abstractions are α-convertible if and only if their bodies are α-convertible after replacing the bound variables with a common fresh name. From this definition it follows that ∼ α is an equivalence relation, as shown in [3].
As it is the case in [11], α-equivalent terms become identical when submitted to the same substitution. This is due to the fact that abstractions are uniformly renamed, and that the new name chosen by the χ function is determined only by the restriction of the substitution to the free variables of the terms, which is the same one if the terms are α-equivalent. This is proven in [3], and we just mention the corresponding lemma here: From now on we present definitions and results not included in the library [2]. Firstly, we have proven that this definition of alpha equivalence is decidable: Given a binary relation , we define its α-reflexive-transitive closure as follows: where Rel is the type of binary relations over terms. This is the kind of closure that will be applied to our one-step reduction relations. It represents sequences of steps allowing α conversions, which have to be made explicit because we are dealing with concrete terms, i.e. terms not identified under α conversion. In informal notation we shall write the α-reflexivetransitive closure of a relation with the classical two-headed arrow. From the definition given we can easily prove that, for any relation , M N implies M N, and that is transitive. The first proof is straightforward using the constructors append and refl. Transitivity is proven by induction on the definition of α-star. Therefore we have, in Agda: Following Kashima [8], we define β -contraction taking into account the position where the contracted redex appears in the term relative to the other redexes. We start by defining two auxiliary functions: isAbs is a predicate that decides whether a term is an abstraction and countRedexes a function that counts the number of β -redexes in a term. We need to prove that isAbs is decidable before being able to define countRedexes, since the number of redexes for an application depends on whether the left term is an abstraction. The proof is straightforward: Considering the linear syntax of terms, redexes will be numbered in a left-to-right fashion, starting from zero. We shall start by defining the contraction of the n-th redex as a relation between terms depending on the natural number n.
The outer-redex constructor allows the contraction of the outermost redex, numbered as the one at position zero. The next four constructors are used to perform contractions inside applications. In order to determine the number of the redex contracted we need to identify whether the left hand side term of the application is an abstraction or not (which is necessary to know whether we are stepping over a redex to reduce an inner one). Finally, the abs constructor allows contractions inside an abstraction.
One-step β -reduction (−→ β ) from M to N can now be defined as the existence of a natural number n such that N can be obtained by contracting the n-th redex from M. We use Agda's dependent ordered pair constructor Σ to express existential quantification.
It is easily proven by structural induction that this definition is equivalent to the compatible (with the syntactic constructors) closure of ordinary β -contraction.
One interesting result that will be useful in our development is the following α-β compatibility property: which we state in Agda as the following lemma: We finally introduce β -reduction β as the α-reflexive-transitive closure of the contraction −→ β :

The Standardization Theorem
In the present section we show the formalization of the Standardization Theorem in Constructive Type Theory that follows the proof given by Kashima in [8]. For the sake of clarity, some lemmas are presented in a different order than the one proposed by Kashima. Nonetheless, the formalized results and definitions are the same unless otherwise stated.

Standard Reduction Sequences
A reduction sequence is a sequence of terms M 0 , M 1 , ..., M n such that M i+1 is obtained from M i by the contraction of some redex, i.e., (∀ i ∈ 0...n−1) M i −→ β M i+1 . We call a reduction sequence standard if and only if subsequent steps are non decreasing in the number of the redex contracted. Kashima defines a standard beta reduction sequence as: We implement this notion in Agda by defining a relation indexed on a natural number that keeps track of the lower bound allowed for the next redex to be contracted.
The relation is reflexive and allows for α-steps, which do not appear explicitly in Kashima's definition because the latter relies on the (informal) syntactic identification of α convertible terms. The "three dots" of Kashimas's sequence M 0 , M 1 , ..., M k are implemented as follows: we can append a term to the reduction sequence provided that it can be obtained by the contraction of a redex at a position greater than or equal to the current lower bound. Using this relation the Standardization Theorem can be precisely stated as the existence of a standard sequence between two terms among which there is a β -reduction:

Two Useful Reduction Relations
The next step is to capture the existence of a standard sequence as an inductively defined reduction relation between terms. To this end, Kashima introduces two auxiliary one-step reduction relations: −→ l stands for leftmost reduction and corresponds to the contraction of the leftmost redex, i.e. the one at position zero: −→ hap stands for head contraction in application and represents the contraction of the redex in the head position of a chain of applications, i.e.: We define this relation in Agda as follows: Now l and hap are defined as the α-reflexive-transitive closures of −→ l and −→ hap respectively.
The first two lemmas state that head reduction in application hap is compatible with application and substitution respectively. • Case refl: We have to prove (M P) hap (M P), which follows by refl.
• Case α-step: Assume that M hap N follows from M hap N and N ∼ α N. Then, we obtain M P hap N P from the induction hypothesis, and since N P ∼ α N P, we construct our goal using st-alpha.
• Case append: Assume M hap N follows from M hap K and K −→ hap N. Then we can obtain M P hap K P from the induction hypothesis and K P −→ hap N P from rule hap-chain applied to K −→ hap N. From these, we construct our goal using append.
In order to prove that substitution preserves the head reduction relation, we need two lemmas from the substitution library [2]. The first one states that substituting y for x and then N for y yields a result αequivalent to substituting N for x, provided y is fresh enough. The second one is a form of the substitution composition lemma: • Case hap-chain: We need to prove that there exists a term K such that Kashima originally formulates the previous result just for single substitutions, i.e., of the form [x := P]. Our result using multiple substitutions will allow us to rely only on structural induction in our proofs, as we shall see later. We can easily extend the previous result to hap : Proof. By induction on M hap N: • Case refl: Direct using refl.
• Case α-step: Assume M hap N and N ∼ α N. Then, we obtain M • σ hap N • σ from the induction hypothesis, and by lemmaM∼M'→Mσ ≡M'σ mentioned in Section 2, we have that N • σ ≡ N • σ , so we construct our goal using the α-step rule, since ∼ α is reflexive.
• Case append: Assume M hap N follows from M hap K and K −→ hap N.
Then we can obtain M • σ hap K • σ from the induction hypothesis and (∃N )(K • σ −→ hap N ∧ N ∼ α N • σ ) from the previous lemma (lem-hap-subst) applied to K −→ hap N. From this, using α-star-single we construct K • σ hap N and since N ∼ α N we obtain K • σ hap N from rule α-step. Finally, we prove our goal from the transitivity of hap .
Finally, notice that head reduction in application implies leftmost reduction: And therefore the same inclusion holds for their α-reflexive-transitive closures:

Standard Reduction
Using hap , Kashima characterizes the existence of a standard sequence as a further reduction relation st , which stands for standard reduction, as follows: The intention behind this relation is to characterize standard reduction sequences inductively. This definition allows us to perform as many hap steps as we want. After that, if we reach a variable, then we are done since we cannot do any more reductions (st-var). If the term is an application A B, then we can continue performing standard reductions on A and then on B (st-app). Finally, if the term is an abstraction, we can continue performing standard reductions inside the body of the abstraction (st-abs). Note that we are not forced to reduce all of the redexes that we encounter; given a redex, we can still apply st-app while skipping the head reduction. The last constructor (st-alpha) allows us to perform α-conversion. The preceding explanation may have shown that standard reductions correspond to standard sequences of reductions, i.e. that the former relation is included in the latter one. This is enough for proving the standardization theorem, as will be shown in the next subsection. We have further proven that actually the characterization of standard reduction sequences by the relation of standard reduction is complete, i.e. that the converse inclusion aldo holds. The notion of standard reduction can be extended to substitutions. We say that substitution σ standard-reduces to σ (σ → st σ ) if and only if for all variables x, σ x st σ x.  • For the st-alpha case, we assume M st A and A ∼ α A. We use constructor st-alpha applied to the induction hypothesis L st A and A ∼ α A to complete our goal.
We can now use the preceding lemma to prove that substitution is preserved by the st relation. This lemma is key to the proof and was originally stated by Kashima for single substitutions as: M st N and P st Q =⇒ M[z := P] st N[z := Q]. By taking the substitution to be an arbitrary (multiple) σ instead of the particular case where we replace just one variable z, we obtain a definition of substitution by structural recursion, and hence we can prove this result using just structural induction (see [3] for a detailed explanation). The substitution lemma is then stated as follows: • Case st-app: ). Due to the definition of the choice function χ, z is fresh in every term and substitution involved. We can now prove that: Note that by using multiple substitutions, our induction hypothesis is strong enough to allow us to use it with any pair of substitutions σ , σ as long as σ → st σ . Therefore, we can extract the following induction hypothesis from A st B: We can prove that σ ≺+(x, z) → st σ ≺+(x, z) because the st relation is reflexive (lemma st-refl), so replacing x for z in both substitutions will preserve the → st relation. So, from (2), (3) and constructor st-abs we obtain that M • σ st ňz (B • σ ≺+(x, z)) and we obtain our thesis using st-alpha, since ňz (B • σ ≺+(x, z)) ∼ α (ňx B) • σ , .
• Case st-alpha: We assume that M st N and N ∼ α N and want to prove that M • σ st N • σ . From the induction hypothesis we get that M • σ st N • σ . In addition, we know that N • σ ∼ α N • σ , since they are equal (lemmaM∼M'→Mσ ≡M'σ ) and ∼ α is reflexive. From these we obtain our goal using the st-alpha rule.
The following lemma states that if there is a standard reduction to a term that is a redex (λ Using this result, we can now prove that any β -contraction can be also inserted into a standard reduction: • The case outer-redex follows directly from the previous lemma st-abs-subst.
• All the application cases are solved by simply using st-app applied to the induction hypotheses.
For example, if M −→ β N was constructed using the rule appAbsL then we know that M = A C, N = B C and (A C) β (B C) @ (suc n), with A β B @ n for some n. Since M is an application, L st M must have been constructed using either the st-app constructor or the st-alpha constructor. We will deal with all the st-alpha cases uniformly at the end, so let us focus on the st-app case for now. We know that L hap A C , A st A and C st C. We want to prove that L st B C. From A st A and A −→ β B we get that A st B by the induction hypothesis. Finally, we prove this case using the st-app rule applied to L hap A C , A st B and C st C. The proofs for the other three application cases follow the same structure.
• The abs case also follows a similar pattern. We know that λ xA −→ β λ xB where A −→ β B.
Therefore, considering that L st λ xA was constructed using the st-abs rule, we have that L hap λ xA and A st A for some A . The induction hypothesis applied to A st A and A −→ β B gives us that A st B, and we obtain our goal L st λ xB using the st-abs rule applied to L hap λ xA and A −→ β B.
• In all the previous cases we ignored the case where L st M was constructed using the st-alpha constructor since we can prove this uniformly for all cases. We know that L st M and M ∼ α M. In order to use the induction hypothesis we would need to have that M −→ β K for some K. Since we know that M −→ β N and M ∼ α M we can use the α-β diamond property of Section 2 (lem-β α), to obtain a term K such that M −→ β K and K ∼ α N, so we prove our goal using the st-alpha rule.
Finally, using this last result we can prove that if there is a sequence of β -reductions from M to N, then there is also a standard reduction between those two terms. The proof is a direct induction on M β N:

Standard Sequences
The next results show the relation between the reduction relations l , hap and st with the existence of a standard reduction sequence. Firstly notice that, since leftmost reductions always involve the reduction of redexes at position 0, then any sequence of leftmost reductions is a standard reduction sequence with lower bound 0. The next result about seqβ -st will be useful to prove the subsequent lemma. • Case nil: We know that seqβ -st M M 0 and therefore we construct our goal, seqβ -st (λ xM) (λ xM) 0, using nil.
• Case α-step: We know that seqβ -st M K n for some K such that K ∼ α N. From the induction hypothesis we get that seqβ -st (λ xM) (λ xK) n and since K ∼ α N we can easily prove that λ xK ∼ α λ xN. From this we prove the case using the st-alpha constructor. • Case β -step: We know that seqβ -st M K n for some K such that K β N @ m with n ≤ m. Similarly to the last case, the induction hypothesis tells us that seqβ -st (λ xM) (λ xK) n and from K β N @ m we can construct (λ xK) β (λ xN) @ m using rule abs. Finally, we prove our goal using constructor β -step.
As for the st relation, if M st N then there is a standard reduction sequence from M to N, which we code in Agda as the existence of a lower bound for a standard reduction sequence: • The case st-var can be easily proven using lemma hap→seqβ st: since M hap x, then there is a standard reduction sequence (with lower bound 0) from M to x.
• Similarly, the case st-abs also relies in this lemma, and the induction hypothesis: we know from hap→seqβ st that there is a standard reduction sequence with lower bound 0 from M to λ x.A; the induction hypothesis tells us that there exists a natural number n such that there is a reduction sequence from A to B with lower bound n. Therefore, using lemma abs-seq we conclude that there must be a standard reduction sequence from M to B with lower bound n since 0 ≤ n.
• The case for st-app is slightly trickier since the lower bound that exists depends on certain characteristics of the terms involved: If M st N was constructed using the constructor st-app, that means that for some terms A, B , C and D: We need to prove that there is a standard reduction sequence from M to (C D). Using the induction hypotheses, let m and n be the lower bounds for the standard reduction sequences from A to C and from B to D respectively: 1. If C is not an abstraction, and B ∼ α D 2 , then the lower bound for the standard reduction sequence will be m. 2. If C is not an abstraction, and B ∼ α D, then the lower bound for the standard reduction sequence will be n + countRedexes C. 3. If C is an abstraction, and B ∼ α D, then the lower bound for the standard reduction sequence will be suc (n + countRedexes C ). 4. If C is an abstraction, and B ∼ α D, then we need to do some further case analysis using the following lemma: Note that if a reduction sequence ends in an abstraction, by appending the same application (or an α-equivalent one) to all of the terms in the sequence, the lower bound will remain the same if and only the abstraction is generated in the last beta step of the sequence and therefore does not affect the redex count in β -reductions. However, if the abstraction appears before that, then the lower bound of the reduction sequence must be increased by one, since a new redex at position 0 is formed. From this lemma we conclude that the lower bound must be either m or suc m for this case.
• Finally, for the st-alpha case, we have that M st N and N ∼ α N and we want to prove the existence of a standard reduction sequence from M to N. The induction hypothesis gives us a standard reduction sequence from M to N and we can directly perform an alpha step to N by using the α-step constructor from seqβ -st.
The Standardization Theorem finally follows from this last result and lemma β →st that states that M β N implies M st N:

The Leftmost Reduction Theorem
A quite relevant corollary of the Standardization Theorem is the Leftmost Reduction Theorem, which states that if a term M has a normal form, then the leftmost-outermost reduction strategy will find it. In the present section we show how this property can be derived from standardization. It is worth noticing that this proof was developed as part of the present work and is not present in Kashima's article.
We can directly characterize a term in normal form as one without redexes using the countRedexes function from section 2: In order to prove this result, we must first consider some lemmas. The first one states that the number of redexes of two α-equivalent terms is the same, which easily follows by induction on M ∼ α N: The second lemma states that if a term M β -reduces to a term N in normal form, then the contracted redex must be the leftmost redex of M, i.e., the one at position zero: Proof. We proceed by induction on M β N @ n • Case outer-redex: we have that (λ xA) B β B[x := A] @ 0. Our goal follows directly since rule outer-redex contracts the redex at position 0.
• Case appNoAbsL: we have that (AC) β (BC) @ n where A β B @ n, A is not an abstraction and (B C) is in normal form. From this, we know that countRedexes B + countRedexes C ≡ 0, and therefore countRedexes B ≡ 0 which allows us to use the induction hypothesis with A β B @ n and conclude that n ≡ 0.
• Case appAbsL: we have that (AC) β (BC) @ (suc n) where A β B @ n, A is an abstraction and (B C) is in normal form. Since (B C) is in normal form B cannot be an abstraction, but this is a contradiction since A β B @ n and A is an abstraction because contracting a redex in an abstraction always results in an abstraction (rule abs).
• Case appNoAbsR: we have that (C A) β (C B) @ (countRedexesC + n) where A β B @ n, C is not an abstraction and (C B) is in normal form. From this we know that countRedexes C ≡ 0 and countRedexes B ≡ 0. From the induction hypothesis we have that n ≡ 0, and since countRedexes C ≡ 0, n + countRedexes C ≡ 0.
• Case appAbsR: we have that (C A) β (C B) @ suc (countRedexesC + n) where A β B @ n, C is an abstraction and (C B) is in normal form. However, this is a contradiction since (C B) cannot be in normal form if C is an abstraction.
• Case abs: we have that λ xA β λ xB @ n where A β B @ n and λ xB is in normal form. From this we know that B must be in normal form too and we can call the induction hypothesis for A β B @ n, concluding that n ≡ 0.
Finally, notice that a standard sequence with lower bound 0 must be a sequence of leftmost reductions, since all of the β -steps must involve the contraction of the redex at position 0, i.e. a leftmost reduction. • Case nil: We have that seqβ -st A A 0 and we need to prove that A l A, which follows by constructor refl.
• Case α-step: We have that seqβ -st A B n with B ∼ α B and nf B. From this, we have that countRedexes B ≡ 0 by lemma α→sameRedexCount and therefore, using the induction hypothesis we obtain A l B'. Finally, we construct our goal using rule α-step. • Case β -step: We have seqβ -st A B n and B β B @ n , where n ≤ n and countRedexes B ≡ 0.
Using lemma nf→l we have that n ≡ 0, and so n ≡ 0. We then apply lemma seqβ 0→l to seqβ -st A B 0 and get that A l B . Note that since n ≡ 0, we also have that B −→ l B. Finally, from A l B and B −→ l B we conclude that A l B using rule append.
Finally, if we have that M β N, the Standardization Theorem lets us conclude that there exists a standard reduction sequence from M to N. Therefore, the desired property follows directly combining this result and the previous lemma: leftmost-nf : ∀{M N} -> M →→β N -> nf N -> M →→l N leftmost-nf M→→β N crN≡0 = seqst→l (proj2 (standardization M→→β N)) crN≡0

Conclusions
In this work we have extended some metatheoretical results from [3] by formalizing a proof of the Standardization Theorem in Lambda Calculus using Constructive Type Theory. We use a concrete approach to λ -terms and the notion of multiple substitution. The latter enables us to proceed by structural induction only, producing proofs that are easy to follow, yet fully formal. This work has also served to showcase the usefulness of the library produced in [2] and its suitability for the formalization of other metatheoretical properties of the Lambda Calculus. It is worth highlighting that the definitions and lemmas used to handle syntax and substitutions did not need to be modified or extended in any way and could be rapidly put into use by a programmer with a minimal training in Agda, namely the first author while working on his Master's thesis [4]. The Agda code reported in this paper is 890 lines long.
Other efforts to formalize Kashima's proof in the literature include one by Guidi in Matita [7] and another one by Vyšniauskas and Emerich in Coq [6]. However, what sets our development apart from these efforts is the use of a concrete syntax with names and our definition of multiple substitution. While this allows us to prove our lemmas using a clean structural inductive argument, they use a nameless syntax based on de Brujin indexes which results in some inductions being done on the size of the λterms. Another effort worth highlighting is that of McKinna and Pollack, who formalized a proof of the Standardization Theorem due to Takahashi [12] using the LEGO proof assistant [9].
Within the chosen syntax approach, we have to consider the work by Vestergaard and Brotherston [13] which uses modified rules of α-conversion and β -reduction based on unary substitution to formally prove the Church-Rosser theorem in Isabelle-HOL. Substitution does not proceed in cases of capture and they use explicit α-conversion to perform the renaming achieved by our substitution. As a consequence, their development requires an administrative layer of reasoning for showing that α-conversion and β -reduction interact correctly. This consists in a rather complex definition of a new auxiliary relation for α-conversion, which we do not need.
In addition to proving the Standardization Theorem, Kashima proves a few other interesting results which could be a good follow up to the present work, e.g. the Quasi-Leftmost Reduction Theorem. An infinite β -reduction sequence is called quasi-leftmost if it contains infinitely many leftmost reduction steps −→ l . As a corollary of the Standardization Theorem it can be proved that if M has a β -normal form, then there is no infinite quasi-leftmost β -reduction sequence from M.