On the Elementary Affine Lambda-Calculus with and Without Fixed Points
TThomas Seiller & Steffen Jost (Eds.): DICE-FOPARA 2019EPTCS 298, 2019, pp. 15–29, doi:10.4204/EPTCS.298.2 c (cid:13)
Nguyễn
L. T. D.This work is licensed under theCreative Commons Attribution License.
On the Elementary Affine Lambda-calculuswith and Without Type Fixpoints
Lê Thành Dũng N
GUYỄN ∗ LIPN, UMR 7030 CNRS, Université Paris 13, France [email protected]
The elementary affine λ -calculus was introduced as a polyvalent setting for implicit computationalcomplexity, allowing for characterizations of polynomial time and hyperexponential time predicates.But these results rely on type fixpoints (a.k.a. recursive types), and it was unknown whether this fea-ture of the type system was really necessary. We give a positive answer by showing that without typefixpoints, we get a characterization of regular languages instead of polynomial time. The proof usesthe semantic evaluation method. We also propose an aesthetic improvement on the characterizationof the function classes FP and k -FEXPTIME in the presence of recursive types. The elementary affine λ -calculus Elementary Linear Logic (ELL), introduced by Girard [9], is alogic that can be seen as a typed functional programming language through the proof-as-programs cor-respondence. Its typing rules ensure that a function can be expressed if and only if it is elementaryrecursive (as is expounded in detail in [6]), hence the name. (This is an instance of the “type-theoretic”or “Curry–Howard” approach to implicit computational complexity.) This was refined by Baillot [1] intoa characterization of each level of the k -EXPTIME hierarchy, in an affine variant of ELL.A later improvement by Baillot, De Benedetti and Ronchi [2] consisted in turning this logic intoan actual type system for a functional calculus with good properties (e.g. subject reduction), called the elementary affine λ -calculus . In this paper, we shall call their system µ EA λ – the reason for the µ willsoon become clear. The main result about it is: Theorem 1.1 ([2]) . The programs of type ! Str ⊸ ! k + Bool in µ EA λ decide exactly the languages inthe class k -EXPTIME . In particular ! Str ⊸ !! Bool corresponds to polynomial time (P) predicates.
Here are some indications for the reader unfamiliar with linear or affine type systems: • a program of type A ⊸ B uses its input of type A at most once to produce its output of type B ; • ! A means roughly “as many A ’s as you want”, so a function which uses its argument multiple timescan be given a type of the form ! A ⊸ B ; • in usual linear or affine logic, one can convert a ! A into a A ; however, in the elementary affine λ -calculus, there is a restriction which makes the exponential depth (number of ‘!’ modalities)meaningful, one cannot perform such a depth-changing operation – this is why the depth k of theoutput ! k Bool (i.e. ! ( . . . ( ! Bool )) with k ‘!’) controls the complexity; • the type of booleans is defined as Bool = ∀ α . α ⊸ α ⊸ α , and it has two inhabitants; • Str = ∀ α . Str [ α ] , with Str [ α ] = ! ( α ⊸ α ) ⊸ ! ( α ⊸ α ) ⊸ ! ( α ⊸ α ) , is the type of Churchencodings of binary strings : the string w . . . w n ∈ { , } ∗ is represented as the function which, forany type A , takes as input f : A ⊸ A and f : A ⊸ A , and returns f w ◦ . . . ◦ f w n . ∗ Partially supported by the ANR project ELICA (ANR-14-CE25-0005). λ -calculus with and without type fixpoints Type fixpoints and Scott encodings
We wish to draw attention to a particular feature of this language:the presence of type fixpoints , a.k.a. recursive types . An example is the type of Scott binary strings : Str S : = ∀ α . ( Str S ⊸ α ) ⊸ ( Str S ⊸ α ) ⊸ α ⊸ α In the elementary affine λ -calculus as defined in [2], this recursive equation can be turned into a validtype definition, by using a fixed point operator µ on types (this explains our name µ EA λ ): Str S : = µβ . ∀ α . ( β ⊸ α ) ⊸ ( β ⊸ α ) ⊸ α ⊸ α The idea is that strings are represented by their “pattern-matching” function (destructor): if u is a Scottbinary string, then u f f x morally means “if u represents the empty word, return x ; else, return f c applied to v where c ∈ { , } is the first letter and v represents the suffix”. Formally, we associate to eachstring w ∈ { , } ∗ a µ EA λ -term S ( w ) of type Str S : S ( ε ) = λ f . λ f . λ x . x S ( · w ′ ) = λ f . λ f . λ x . f S ( w ′ ) S ( · w ′ ) = λ f . λ f . λ x . f S ( w ′ ) This encoding of strings has been used to give a characterization of function classes in µ EA λ : Theorem 1.2 ([2]) . The programs of type ! Str ⊸ ! k + Str S in µ EA λ compute exactly the functions inthe class k -FEXPTIME . In particular ! Str ⊸ !! Str S corresponds to FP . Our contributions
There are two natural questions concerning the necessity of type fixpoints: • In the interface: it is possible to characterize this hierarchy of function classes using a functiontype involving only Church encodings? • In the implementation: the extensional completeness proof for the predicate classes (Theorem 1.1)makes use of the type
Str S (to represent configurations of Turing machines), even though this typedoes not appear in the statement; could one avoid recursive types in the proof? This question hasbeen raised by Baillot in the conclusion of [1].In this paper, we answer both questions. The first one has a positive answer: Theorem 1.3.
The programs of type ! Str ⊸ ! k + Str in µ EA λ compute exactly the functions in theclass k -FEXPTIME . In particular ! Str ⊸ ! Str corresponds to FP . An advantage of this characterization is that it reflects the fact that composing a k -FEXPTIME func-tion f with a l -FEXPTIME function g gives a ( k + l ) -FEXPTIME function: since any µ EA λ -term oftype A ⊸ B lifts to a term of type ! k A ⊸ ! k B (this is called “functorial promotion”, cf. Proposition 2.2),we can compose the terms f : ! Str ⊸ ! k + Str and g ( k ) : ! k + Str ⊸ ! ( l + )+ k Str to obtain a term of type!
Str ⊸ ! ( k + l )+ Str . In particular FP is closed under composition. A characterization of FP in µ EA λ bya function type whose input and output types coincide was proposed in [2], but it is less natural: a stringis represented as a pair of its length (Church-encoded) and its contents (Scott-encoded).As for the second question, we should first mention that Girard’s original characterization of elemen-tary recursive functions in ELL does not involve type fixpoints. This can be replayed in the elementaryaffine λ -calculus without type fixpoints, which we shall denote by EA λ . A remark for the readers acquainted with typed λ -calculi: there is no “positivity” constraint imposed, yet those recur-sive types are harmless for the normalization property, as the untyped version of the elementary affine λ -calculus is alreadynormalizing. The analogous property for ELL was already remarked in [9]. guyễn L.T.D. 17
Theorem 1.4 ([1]) . The class of elementary recursive functions is the union, over k ∈ N , of the classesof functions computed by programs of type ! Str ⊸ ! k Str in EA λ . (The detailed proof given in [1] is for Elementary Affine Logic; it can be directly transposed to EA λ .)However, the characterization of P by ! Str ⊸ !! Bool fails in EA λ , as we show: Theorem 1.5.
The programs of type ! Str ⊸ !! Bool in EA λ decide exactly the regular languages . Thisis also the case for the EA λ -terms of type Str ⊸ ! Bool . This result is surprising for a few reasons: the class of languages obtained is unexpectedly small, andit hints at connections between EA λ and formal language theory (the conclusion will discuss this further).The proof techniques for the above theorem are quite different from those used in [2]: instead of boundingthe syntactic normalization process, we take inspiration from the tradition of implicit complexity in the simply typed λ -calculus (ST λ ), in particular from: Theorem 1.6 (Hillebrand & Kanellakis [14]) . In the simply typed λ -calculus , the languages decided byterms of type Str ST λ [ A ] → Bool ST λ – A is a simple type that may be chosen depending on the language– are exactly the regular languages. Here
Str ST λ [ A ] = ( A → A ) → ( A → A ) → ( A → A ) and Bool ST λ = o → o → o , where o is a basetype. This is proved using the semantic evaluation method (see [19] and references therein). To makethis method work in our case, we need a new result in denotational semantics: Lemma 1.7.
The second-order affine λ -calculus A λ – i.e. the subsystem of EA λ without the exponen-tial modality ‘ ! ’ – admits a non-trivial finite semantics. By “non-trivial” we mean distinguishing the two inhabitants of
Bool = ∀ α . α ⊸ α ⊸ α . The term“second-order” refers to the (impredicative) polymorphism supported by both µ EA λ and EA λ – indeed,the types Bool , Str and
Str S all contain second-order quantifiers ( ∀ ). The lemma means morally thatone cannot represent infinite data types in µ EA λ without using the exponential modality – whereas in µ EA λ , the exponential-free type Str S encodes the infinite set { , } ∗ .Thus, motivated by this question in implicit complexity, we set out to establish the above lemma, andcame up with two approaches: • a “category-theoretic” solution consists in showing the finiteness of a pre-existing model based oncoherence spaces and normal functors; this is the subject of another paper [15]; • a “syntactic” solution, developed in a joint work with P. Pistone, T. Seiller and L. Tortora de Falco,relies on a careful combinatorial study of second-order proof nets; it will be written up in anupcoming paper.The further development of these semantic tools has led to more results on EA λ and/or on ElementaryLinear Logic without type fixpoints, which are beyond the scope of the present paper. This includes analready published joint work with P. Pradic [16] on logarithmic space. Plan of the paper
We recall from [2] the definitions of EA λ and µ EA λ in Section 2, and then quicklyprove Theorem 1.3 in Section 3. The bulk of the paper is Section 4, dedicated to proving Theorem 1.5.The conclusion (Section 5) discusses the above-mentioned new perspectives on EA λ opened up by ourresults and by refinements of Lemma 1.7. Acknowledgments
This work owes a great deal to Thomas Seiller’s supervision. Thanks also toPatrick Baillot, Alexis Ghyselen, Damiano Mazza (an extremely fruitful discussion with Thomas andhim triggered this work) and Pierre Pradic.8 Onthe elementary affine λ -calculus with and without type fixpoints λ -calculus The syntax of elementary affine λ -terms and the reduction rules are given by t , u :: = x | λ x . t | λ ! x . t | t u | ! t ( λ x . t ) u −→ β t { x : = u } ( λ ! x . t ) ( ! u ) −→ ! t { x : = u } where x is taken in a countable set of variables, and t { x : = u } refers to the substitution of all free occur-rences of x in t by u . The reduction rules −→ β and −→ ! are actually the contextual closure of the rulesgiven above, for the obvious notion of context (see [2] for details).We shall also write let ! x ← u in t for ( λ ! x . t ) u (this is just some “syntactic sugar”). The notion of depth of a subterm in a term, defined as the number of exponential modalities ! ( − ) (“exponentials” forshort) surrounding the subterm, will play an important role.As an example, let us formally define the Church-encoded binary strings:for w = w . . . w n ∈ { , } ∗ , w = λ ! f . λ ! f . ! ( λ x . f w ( . . . ( f w n x ) . . . )) The above is essentially Simpson’s linear λ -calculus with thunks [18]. (Other examples of linear λ -calculi with explicit exponentials are given in [12].) We shall now turn this untyped calculus into EA λ by endowing it with its type system – an adaptation of Coppola et al. ’s Elementary Type AssignmentSystem [7]. The grammar of types for EA λ is A :: = α | S S :: = σ ⊸ τ | ∀ α . S σ , τ :: = A | ! σ The two first classes of types are called respectively linear and strictly linear . (We follow the terminologyof [2]; “linear” does not mean exponential-free, it merely means that the head connective is not anexponential.) The reason for restricting quantification to strictly linear types is a technical subtlety relatedto subject reduction (see [7, §7.2]).The typing judgements involve a context split into three parts: they are of the form Γ | ∆ | Θ ⊢ t : σ .The idea is that the partial assignements Γ , ∆ and Θ of variables to types correspond respectively tolinear, non-linear and “temporary” variables; accordingly, Γ maps variables to linear types (denoted A above), ∆ maps variables to types of the form ! σ , while Θ maps variables to arbitrary types. The domainsof Γ , ∆ and Θ are required to be pairwise disjoint. The derivation rules for EA λ are:variable rules Γ , x : A | ∆ | Θ ⊢ x : A Γ | ∆ | Θ , x : σ ⊢ x : σ abstraction rules Γ , x : A | ∆ | Θ ⊢ t : τΓ | ∆ | Θ ⊢ λ x . t : A ⊸ τ Γ | ∆ , x : ! σ | Θ ⊢ t : τΓ | ∆ | Θ ⊢ λ ! x . t : ! σ ⊸ τ application rule Γ | ∆ | Θ ⊢ t : σ ⊸ τ Γ ′ | ∆ | Θ ⊢ u : σΓ ⊎ Γ ′ | ∆ | Θ ⊢ t u : τ quantifier rules Γ | ∆ | Θ ⊢ t : S Γ | ∆ | Θ ⊢ t : ∀ α . S Γ | ∆ | Θ ⊢ t : ∀ α . S Γ | ∆ | Θ ⊢ t : S { α : = A } functorial promotion rule ∅ | ∅ | Θ ⊢ t : σΓ | ! Θ , ∆ | Θ ′ ⊢ ! t : ! σ Γ ⊎ Γ ′ means Γ ∪ Γ ′ with the assumption that the domains of Γ and Γ ′ are disjoint. In the introduction rule (left), α must not appear as a free variable in Γ , ∆ and Θ . guyễn L.T.D. 19In these rules, following the conventions established above, A stands for a linear type, S stands for astrictly linear type and σ and τ stand for arbitrary types. In particular, in the quantifier elimination rule, α can only be instantiated by a linear type. So, for instance, one cannot give the type ! β ⊸ ! β to λ x . x through a quantifier introduction followed by a quantifier elimination; indeed, as one would expect, theonly normal term of this type is λ ! x . ! x . (Despite this, the polymorphism is still impredicative.)Coming back to the example of Church binary strings, one can show by induction thatfor w = w . . . w n ∈ { , } ∗ , x : α | ∅ | f : α ⊸ α , f : α ⊸ α ⊢ f w ( . . . ( f w n x ) . . . ) : α and deduce from this that ⊢ w : Str (recall that
Str = ∀ α . ! ( α ⊸ α ) ⊸ ! ( α ⊸ α ) ⊸ ! ( α ⊸ α ) ).The system µ EA λ is obtained by extending the grammar of types with S :: = . . . | µα . S , and addingnew derivation rules for the type fixpoint operator µ : µ -fold Γ | ∆ | Θ ⊢ t : S { α : = µα . S } Γ | ∆ | Θ ⊢ t : µα . S µ -unfold Γ | ∆ | Θ ⊢ t : µα . S Γ | ∆ | Θ ⊢ t : S { α : = µα . S } Let us recall two basic properties satisfied both by EA λ and µ EA λ , all proved in [2]. Proposition 2.1 (Stratification and linearity [2, Lemma 27]) . Let t be a typable term. • for any subterm of the form λ ! x . u of t, all the occurrences of x must be at depth 1 in u; • for any subterm λ x . u of t, there is at most one occurrence of x in u, whose depth must be 0 in u.As a consequence, the reduction rules are depth-preserving. Proposition 2.2 ( k -fold functorial promotion [2, Proposition 28]) . Let t : σ ⊸ . . . ⊸ σ n ⊸ τ is aclosed elementary affine λ -term and k ≥ . There is a term t ( k ) : ! k σ ⊸ . . . ! k σ n ⊸ ! k τ such thatt ( k ) ( ! k u ) . . . ( ! k u n ) and ! k ( t u . . . u n ) have the same normal form for all closed terms u i : σ i (i ∈ { , . . . , n } ). k -FEXPTIME hierarchy in µ EA λ (proof of Theorem 1.3) First, the soundness part of Theorem 1.3 follows immediately from Theorem 1.2.
Proposition 3.1.
All functions represented by µ EA λ -terms of type ! Str ⊸ ! k + Str are in k -FEXPTIME .Proof.
There exists a coercion !
Str ⊸ ! Str S (by completeness part of Theorem 1.2 applied to theidentity function in FP) which lifts by functorial promotion (Proposition 2.2) to ! k + Str ⊸ ! k + Str S .So any function represented by a term of type ! Str ⊸ ! k + Str is also represented by a term of type!
Str ⊸ ! k + Str S . Thus the soundness part of Theorem 1.2 applies.For the extensional completeness, we also take Theorem 1.2 as our starting point. The idea is toconvert ! Str S into Str with the help of an auxiliary integer which provides an upper bound on the lengthof the string. (Similar ideas appear in [3].)We shall use the type of
Church natural numbers and the usual second-order encoding of pairs:
Nat = ∀ α . ! ( α ⊸ α ) ⊸ ! ( α ⊸ α ) σ ⊗ τ = ∀ α . ( σ ⊸ τ ⊸ α ) ⊸ α The aforementioned upper bound will be an inhabitant of the type
Nat . An integer n ∈ N is representedin Nat by the iterator f f n (formally, n = λ ! f . ! ( λ x . f ( . . . ( f x ) . . . )) with n times f ).To help readability we extend the syntax with the abbreviation0 Onthe elementary affine λ -calculus with and without type fixpoints • u ⊗ v : = λ f . f u v so that u ⊗ v : σ ⊗ τ if u : σ and v : τ given in [2], and introduce some additional syntactic sugar: • let x ⊗ y ← u in t : = u ( λ x . λ y . t ) for u : σ ⊗ τ , and λ ( x ⊗ y ) . t : = λ z . let x ⊗ y ← z in t • case u | x a | y b | ε c : = u ( λ x . a ) ( λ y . b ) c for u : Str S The affine projections π i = λ ( x ⊗ x ) . x i ( i ∈ { , } ) are also defined in [2]. Remark 3.2.
Our definition of λ ( x ⊗ y ) . t is much simpler that the one given in [2], but the drawbackis that it only works when the type of t is linear, i.e. its head connective is not an exponential. Indeed, u : σ ⊗ τ can be instantiated to u : ( σ ⊸ τ ⊸ A ) ⊸ A by the quantifier elimination rule only when A islinear. This condition will hold in our use cases below.Now that we are equipped with all these data types, we can make progress on our proof. Lemma 3.3.
There exists a µ EA λ -term cast : Nat ⊸ ! Str S ⊸ Str which converts a Scott encodinginto a Church encoding, provided that the integer argument is greater or equal to the length of the string.Proof.
Our implementation of cast instantiates the input
Nat on ( α ⊸ α ) ⊗ Str S where α is the eigen-variable of the ∀ in the output Str (recall that S ( ε ) refers to the Scott encoding of the empty word): cast = λ n . λ ! w . λ ! f . λ ! f . let ! g ← n ! ( λ ( h ⊗ u ) . t ) in ! ( π ( g (( λ x . x ) ⊗ w ))) with t = let f ⊗ v ← ( case u | v f ⊗ v | v f ⊗ v | ε ( λ z . z ) ⊗ S ( ε )) in ( λ x . h ( f x )) ⊗ v To explain this functional program, let us reformulate it as an imperative algorithm: t can be consideredas the body of a for loop which alters two mutable variables h : ( α ⊸ α ) and u : Str S . At each iteration,if u is non-empty, its first letter is popped (viewing u as a mutable stack) and h is post-composed witheither f or f depending on this letter.After n iterations starting from h = ( λ x . x ) and u = w , if w is the Scott encoding of w . . . w m , theresult obtained is ( f w ◦ . . . ◦ f w N ) ⊗ ( S ( w N + . . . w m )) where N = min ( n , m ) . In particular, if n ≥ m , thefirst component will be f w ◦ . . . ◦ f w m – which corresponds to the definition of the Church encoding.To obtain the desired upper bound, we recall a lemma from [2]. It is used in the proof of Theorem 1.2in order to simulate Turing machines. Lemma 3.4 ([2]) . Let M be a k-FEXPTIME Turing machine. There is a EA λ -term t M : ! Str ⊸ ! k + Nat computing an upper bound on the running time of M on the given input string. We now have all the ingredients for the extensional completeness proof.
Theorem 3.5.
All k -FEXPTIME functions can be represented by µ EA λ -terms of type ! Str ⊸ ! k + Str .Proof.
Consider any function computed by a k -FEXPTIME Turing machine M . By the completenesspart of Theorem 1.2, we can choose a µ EA λ -term f : ! Str ⊸ ! k + Str S computing this function. Wealso choose a term t M satisfying the conditions of the above lemma. Then the term λ ! w . cast ( k + ) ( t M ! w ) ( f ! w ) : ! Str ⊸ ! k + Str – where cast ( k + ) is the ( k + ) -fold functorial promotion of cast – computes the same function as M .Indeed, the assumption of Lemma 3.3 is satisfied, since for a Turing machine, the length of the output isbounded by the running time. guyễn L.T.D. 21 EA λ (proof of Theorem 1.5) In this section, we wish to show that, in EA λ ( without fixpoints): • all terms t : ! Str ⊸ !! Bool decide regular languages; • moreover, all regular languages can be decided by terms t : Str ⊸ ! Bool .By functorial promotion, the class of languages characterized by
Str ⊸ ! Bool is included in the classcorresponding to !
Str ⊸ !! Bool , so this will entail that both are exactly the class of regular languages.The situation is the opposite of the previous section: the second item (extensional completeness) is easy,while the first (soundness) is hard.Regular languages admit many well-known equivalent definitions, e.g. regular expressions and finiteautomata (with many variants: non-determinism, bidirectionality, etc.). The classic characterizationwhich will prove useful for us is:
Theorem 4.1.
A language is regular if and only if it can be expressed as ϕ − ( S ) , where ϕ : { , } ∗ → Mis a monoid morphism, M is a finite monoid and S ⊆ M. Proposition 4.2.
All regular languages can be decided by EA λ -terms of type Str ⊸ ! Bool .Proof.
Let ϕ : { , } ∗ → M be a morphism to a finite monoid M . Without loss of generality, we mayassume that the underlying set of M is { , . . . , k } , and the identity element of the monoid is 1. Werepresent the monoid elements in EA λ as inhabitants of the type M = ∀ α . α ⊸ . . . α ⊸ α ; the element i is mapped to the term m i = λ x . . . . λ x k . x i . We define: • δ c = λ m . m m ϕ ( c ) · . . . m ϕ ( c ) · k : M ⊸ M for c ∈ { , }• for S ⊆ M , χ S = λ m . m b . . . b k : M ⊸ Bool where b i = true (resp. false ) if i ∈ S (resp. i / ∈ S ).Then the language ϕ − ( S ) is decided by the term λ w . let ! d ← w ! δ ! δ in ! ( χ S ( d m )) .Next, to prepare the ground for our proof of soundness in EA λ , we review our direct inspiration inthe simply typed λ -calculus: the proof of one direction of Theorem 1.6. The goal is to show that anysimply typed λ -term t : Str ST λ [ A ] → Bool ST λ , where A is an arbitrary simple type, decides a language L ST λ ( t ) which is regular . This was done using automata in [14], but we find it simpler to work withmonoid morphisms (though this is, in the end, merely a different presentation of the same proof). We shall omit the subscripts in the types
Str ST λ [ A ] and Bool ST λ in this subsection.Let us fix a simple type A . The fundamental idea is that, given any denotational semantics J − K : • the denotation J w K ∈ J Str [ A ] K of the encoding of w ∈ { , } ∗ is enough to determine J t w K ∈ J Bool K – this is simply the compositionality of the semantics; • provided the semantics is non-trivial , i.e. J true K = J false K , this subsequently determines t w .Formally, let us define ϕ A : { , } ∗ → J Str [ A ] K by ϕ A ( w ) = J w K ; then if J − K is non-trivial, L ST λ ( t ) = ϕ − A ( { ω ∈ J Str [ A ] K | J t K ( ω ) = J true K } ) To show that L ST λ ( t ) is regular, we shall apply Theorem 4.1 to this equation. We must make sure that:2 Onthe elementary affine λ -calculus with and without type fixpoints • J Str [ A ] K can be endowed with a monoid structure, in such a way that ϕ is a monoid morphism –this is caused by the use of Church encodings ; • J Str [ A ] K is finite – thanks to the existence of a finite semantics for the simply typed λ -calculus.Our choice of semantics, to satisfy both conditions, is the usual interpretation of types by mere sets(called the “full type frame” in [14]): J A → B K = J B K J A K , with J o K = { , } for the base type. Any choicefor J o K with at least two elements makes the semantics non-trivial. Furthermore, since J o K is finite, thedenotations of all types are also finite.Finally, in order to define a monoid structure on J Str [ A ] K , observe that J Str [ A ] K = (cid:16) J A → A K J A → A K (cid:17) J A → A K ∼ = End ( J A K ) End ( J A K ) where End ( J A K ) is the monoid of maps from J A K to itself, endowed with function composition. Thus,the right-hand side can be seen as a product of monoids. Proving that ϕ is a morphism can then be donecomponentwise; the condition to be checked can be expressed as: ∀ ( f , f ) ∈ End ( J A K ) , ( w J w K ( f , f )) is a morphism { , } ∗ → End ( J A K ) By definition, w = λ f . λ f . λ x . f w ( . . . ( f w n x ) . . . ) (where w = w . . . w n ) so ∀ ( f , f ) ∈ End ( J A K ) , J w K ( f , f ) = f w ◦ . . . ◦ f w n therefore ϕ is none other than the product, over all ( f , f ) ∈ End ( J A K ) , of the monoid morphisms { , } ∗ → End ( J A K ) defined by c f c for c ∈ { , } . Remark 4.3.
This reasoning can be made to work with any finite semantics of ST λ , not just sets.An interesting choice is the “linearized Scott model” : as remarked by Terui [19], in that semantics,the points in the denotation of a Church-encoded word correspond to nondeterministic finite automataaccepting that word. This idea is also at the heart of Grellois and Melliès’s semantic approach to higher-order model checking [11, 10]. EA λ Our goal is now to emulate the above proof to show that the EA λ -terms of type ! Str ⊸ !! Bool decideregular languages. (The result for
Str ⊸ ! Bool then follows by functorial promotion.) While the coreof the semantic evaluation argument is similar, we need to do some syntactic analysis first before comingto this point.
Our proof relies on some general properties of EA λ . The two following ones were established in [2]. Proposition 4.4 (Reading property for booleans [2, Lemma 31(i)]) . The only closed inhabitants of thetype !! Bool are !! true and !! false . ( true = λ x . λ y . x and false = λ x . λ y . y) Proposition 4.5 (!-inversion [2, Lemma 29(i)]) . If ∅ | ∆ | ∅ ⊢ t : ! σ , then t = ! t ′ for some term t ′ . This model is obtained from a semantics of linear logic as its exponential co-Kleisli category, i.e. via the translation A → B : = ! A ⊸ B . The resulting category embeds fully and faithfully into the usual category of Scott domains and continuousfunctions, hence the name. See [19] for a short self-contained definition. guyễn L.T.D. 23We will also make use of a truncation operation on EA λ -terms. (To our knowledge, it has notappeared previously in the literature.) Its purpose is to erase all exponentials. This will be how the stratification property of EA λ (cf. Proposition 2.1) comes into play. Definition 4.6.
The truncation at depth 0 k − k is defined inductively on terms as: k ! t k = ( λ x . x ) k ( λ ! x . t ) k = λ x . k t k k λ x . t k = λ x . k t k k t u k = k t k k u k k x k = x and on types as (using the abbreviation = ∀ α . α ⊸ α ): k ! σ k = k σ ⊸ τ k = k σ k ⊸ k τ k k α k = α k∀ α . σ k = ∀ α . k σ k Proposition 4.7.
If a typing judgment Γ | ∆ | ∅ ⊢ t : σ is derivable in EA λ , then, writing k Γ k forx : k τ k , . . . , x n : k τ n k if Γ = x : τ , . . . , x n : τ n , the judgment k Γ k | ∅ | ∅ ⊢ k t k : k σ k is derivable.In particular, if t : σ is a closed term, then k t k : k σ k .Proof. By a mostly straightforward induction on the type derivation. Even so, let us treat a case involvinga small subtlety: when the derivation ends with a quantifier elimination. In that case, the inductionhypothesis gives us the typing judgment k Γ k | ∅ | ∅ ⊢ k t k : ∀ α . k S k , and from this we must derive k Γ k | ∅ | ∅ ⊢ t : k S { α : = σ }k . What the same instantiation rule can give us from our premise is k Γ k | ∅ | ∅ ⊢ t : k S k { α : = k σ k } . One is therefore led to hope that k S k { α : = k σ k } = k S { α : = σ }k .Indeed, this can be checked by distinguishing, for each occurrence of α in σ , two possible cases: eitherit is at depth 0 and remains in k S k , or at depth ≥ k S k . Remark 4.8.
The above proof is the reason why we do not generalize here our truncation operation toa “truncation at depth k ” for k ≥
1, which would erase all exponentials of depth > k . Indeed, a typicalexample for which the above reasoning would fail is the truncation at depth 1 of ∀ α . ! α ⊸ α instantiatedwith α : = ! τ . So these higher depths truncations would need additional conditions to be well-behaved. Proposition 4.9.
For all k ∈ N and all EA λ -terms t , t ′ , if t −→ t ′ , then k t k −→ ∗ k t ′ k (this also appliesto untyped terms which satisfy the stratification property, i.e. the conclusions of Proposition 2.1).Proof. If the redex contracted in t to obtain t ′ is at depth ≥
1, then one can prove that k t k = k t ′ k .Otherwise, by induction on the context of the redex, one can restrict to the case where t = u v and theapplication of u to v is the contracted redex. We proceed by case analysis: • If u = λ x . u ′ , then t ′ = u ′ { x : = v } . We use the fact that x appears only at depth zero in u ′ (Proposi-tion 2.1) to show that k u ′ { x : = v }k = k u ′ k { x : = k v k } . The latter is a reduct of k u k k v k = k t k . • If u = λ ! x . u ′ , then v = ! v ′ and t ′ = u ′ { x : = v ′ } . Moreover, x appears only at depth 1 in u ′ (againby Proposition 2.1). Therefore, k u ′ k does not contain x as a free variable; thus, k t ′ k = k u ′ k is areduct of k t k = ( λ x . k u ′ k ) k v k .A final general observation (unrelated to truncation) before delving into the soundness proof itself: Proposition 4.10.
Let t be a term a free variable x. Suppose that t = t ′ { x : = x } . . . { x n : = x } , where eachx i appears only once in t ′ (so n is the number of occurrences of x in t), and Γ | ∆ | Θ , x : A ⊢ t : τ , where Ais linear (i.e. not of the form ! σ ). Then Γ , x : A , . . . , x n : A | ∆ | Θ ⊢ t : τ . We write t ′ = t { x : = x , . . . , x n } for this situation. (Such a t ′ always exists given t.)Proof. By induction on typing derivations, replacing each rule of the form . . . | . . . | . . . , x : A ⊢ x : σ by arule of the form . . . , x i : A , . . . | . . . | . . . ⊢ x i : A for some i ∈ { , . . . , n } . This is justified as ∀ α . α ⊸ α is the unit to the tensor product used in Section 3. λ -calculus with and without type fixpoints We can now start looking at the languages decided by EA λ -terms. Lemma 4.11.
For any EA λ -term t : ! Str ⊸ !! Bool , there exists u : Str [ σ ] ⊸ . . . ⊸ Str [ σ n ] ⊸ ! Bool (for some n ∈ N ) such that, for all s : Str , t ! s and ! ( u s . . . s ) have the same normal form.Proof. First, one may take t to be in normal form. In that case, the only possible redex in t ! s is theapplication at the root. Moreover, t ! s must be reducible since it is neither !! true nor !! false , cf.Proposition 4.4. Therefore, t = ( λ ! x . t ′ ) (the case t = ( λ x . t ′ ) can be excluded because then t would beof type A ⊸ τ where A is linear, in particular A = ! Str ).The next step is to prove that t = λ ! x . ! t ′′ for some EA λ -term t ′′ . According to the typing rules, thejudgment ∅ | ∅ | ∅ ⊢ t : ! Str ⊸ !! Bool can only be proven by first establishing ∅ | x : ! Str | ∅ ⊢ t ′ :!! Bool . According to the !-inversion property (Proposition 4.5), since the first and third part of the typingcontext are empty and the head connective of the type is ‘!’, t ′ must be of the form ! t ′′ .Finally, since ∅ | ∅ | x : Str ⊢ t ′ : !! Bool must hold (it is the only premise which can lead to theabove judgement on t ′ ), we can apply Proposition 4.10 to t ′′ (indeed, the type Str is linear). Then, theterm u = λ x . . . . λ x m . t ′′ { x : = x , . . . , x m } (where x occurs m times in t ′′ ) enjoys the property claimed inthe lemma statement.Let us focus on the case n = Lemma 4.12.
Let u : Str [ σ ] ⊸ ! Bool be an EA λ -term, and let τ = σ ⊸ σ .There exist EA λ -terms f : τ , f : τ and g : τ ⊸ . . . ⊸ τ ⊸ ! Bool (with m times τ , for some m ∈ N )such that for all s : Str , if s ! f ! f −→ ∗ ! h, then u s and ! ( g h . . . h ) have the same normal form.Proof. We assume that u is in normal form. Since the head connective of Str [ σ ] is not ‘!’, u = λ x . v and x : Str [ σ ] | ∅ | ∅ ⊢ v : ! Bool . We may assume that v contains x as a free variable; otherwise, u is aconstant function and the conclusion we want holds trivially (take m = v : ! θ in normal form (where θ is not necessarily Bool ) suchthat x appears free in v and x : Str [ σ ] | ∅ | ∅ ⊢ v : ! θ . By [2, Lemma 29(ii)], v must be an application: v = p q . . . q k where p is not an application and k ≥
1. Observe that p cannot be of the form λ y . p ′ , since p q would then be a redex. There are two possible cases: • p = x , and then θ = σ ⊸ σ = τ , k = λ -terms q , q : ! τ must be of the form q i = ! q ′ i by !-inversion (Proposition 4.5) • p = ( λ ! y . p ′ ) , in which case x must appear free in q . Indeed, suppose for the sake of contradictionthat q is closed; then ∅ | ∅ | ∅ ⊢ q : θ = ! ρ for some ρ , therefore !-inversion gives us q = ! r for some r , so p q would be a redex.In the second case, we may furthermore take k = k ≥
2, then for all s : Str [ σ ] , the term (( λ ! y . p ′ q . . . q k ) q ) { x : = s } has the same normal form as v { x : = s } (this is analogous to Regnier’s σ -equivalence by redex permutations [17]). And since ∅ | y : ! ρ | ∅ ⊢ p ′ q . . . q k : ! θ , the normal formof p ′ q . . . q k is of the form ! p ′′ (this is again an application of !-inversion).To recapitulate, either v = x ! f ! f or v = ( λ ! y . ! p ) v ′ = let ! y ← v ′ in ! p where x appears free in v ′ ,but not in p . In the latter case, we have x : Str [ σ ] | ∅ | ∅ ⊢ v ′ : ! θ ′ . So, by induction on the size of terms, v = let ! y ← ( . . . ( let ! y l ← x ! f ! f in ! p l ) . . . ) in ! p guyễn L.T.D. 25As a consequence, for all s : Str , if s ! f ! f −→ ∗ ! h (recall that f , f : τ are closed) then u s = ( λ x . v ) s −→ v { x : = s } −→ ∗ ! ( p { y : = ( . . . p l { y l : = h } . . . ) } ) (Morally, we are still trying to permute redexes; the reader may check that there is an analogy betweenthe above operation and Carraro and Guerrieri’s V (( λ x . L ) N ) ( λ x . V L ) N rule [4] for the call-by-value λ -calculus.)Let r = p { y : = ( . . . p l { y l : = z } . . . ) } , where z is a fresh variable, so that the right-hand side can bewritten as ! ( r { z : = h } ) . Since h : τ is a closed subterm of ! ( r { z : = h } ) : ! Bool (we are using subjectreduction here), then it must be true that ∅ | ∅ | z : τ ⊢ r : Bool . Let us now apply Proposition 4.10, usingthe fact that τ = σ ⊸ σ is linear: for some m ∈ N , z : τ , . . . , z m : τ | ∅ | ∅ ⊢ r { z : = z , . . . , z m } : Bool .Finally, we take g = λ z . . . . λ z m . r { z : = z , . . . , z m } . The lemma statement holds with the f , f , m and g that we have constructed.The last purely syntactic step is to use the truncation operation to formulate a variation of the abovelemma. The point is to be able to decide the membership in the language defined by an EA λ -term bycomputing purely in A λ
2. This sets the stage for the use of a semantics of A λ Lemma 4.13.
Let u : Str [ σ ] ⊸ ! Bool be an EA λ -term, and let τ = k σ ⊸ σ k .There exist A λ -terms f : τ , f : τ and g : τ ⊸ . . . ⊸ τ ⊸ ! Bool (with m times τ , for some m ∈ N )such that for all w ∈ { , } ∗ , if w ! f ! f −→ ∗ ! h, then u w and ! ( g h . . . h ) have the same normal form.(Recall that w : Str is the Church encoding of w in EA λ .)Proof. Thanks to the previous lemma, there exist f ′ : σ ⊸ σ , f ′ : σ ⊸ σ and g ′ : ( σ ⊸ σ ) ⊸ . . . ⊸ ( σ ⊸ σ ) ⊸ ! Bool with m times τ , for some m ∈ N , such that the conclusion holds by replacing τ by σ ⊸ σ and f , f , g by f ′ , f ′ , g ′ . The only issue is that f ′ , f ′ , g ′ might not be in A λ
2. The idea istherefore to take f = k f ′ k , f = k f ′ k and g = k g ′ k , and to check that this works.Let h ′ : σ ⊸ σ be such that w ! f ′ ! f ′ −→ ∗ ! h ′ . Since w = λ ! a . λ ! a . ! ( λ x . a w ( . . . ( a w n x ) . . . )) , λ x . f ′ w ( . . . ( f ′ w n x ) . . . ) −→ ∗ h ′ and by truncation λ x . f w ( . . . ( f w n x ) . . . ) −→ ∗ k h ′ k So if h is such that w ! f ! f −→ ∗ ! h , then by confluence [2, Lemma 8], h and k h ′ k have the samenormal form. Therefore, g h . . . h and g k h ′ k . . . k h ′ k have the same normal form. But the latter is noneother than k g ′ h ′ . . . h ′ k .To conclude, observe that: • the normal form of ! ( g ′ h ′ . . . h ′ ) is the same as that of u w by the previous lemma; • by Proposition 4.4, the normal form of g ′ h ′ . . . h ′ is some b ∈ { true , false } ; • since k b k = b , ! k g ′ h ′ . . . h ′ k has the same normal form as u w .By the discussion above, this means that ! ( g h . . . h ) and u w have the same normal form, as desired. We are now ready to conclude our proof of soundness by adapting Hillebrand and Kanellakis’s argument.Let J − K be any non-trivial finite semantics of A λ J A K hasfinitely semantic inhabitants for all A λ A . (Equivalently, if our semantics is a category with aterminal object 1, we require Hom ( , J A K ) to be finite for all A .) Recall that although such a semantics isa central ingredient in our proof, we have simply assumed its existence, which is proved elsewhere (seeLemma 1.7 and the subsequent discussion).6 Onthe elementary affine λ -calculus with and without type fixpoints Definition 4.14.
Let A be a A λ Φ A ( w )( γ , γ ) = γ w ◦ . . . ◦ γ w n for w ∈ { , } ∗ and ( γ , γ ) ∈ End ( J A K ) . In other words, Φ A : { , } ∗ → End ( J A K ) End ( J A K ) is the monoid morphism sending c ∈ { , } to ( γ , γ ) γ c .Here End ( J A K ) refers to the monoid of endomorphisms of J A K in the semantics. Proposition 4.15.
Let w ∈ { , } ∗ and ¯ w : Str be its encoding. For any A λ type σ and A λ -termsf , f : σ ⊸ σ , ¯ w ! f ! f normalizes into some ! h with h : σ ⊸ σ , and Φ A ( w )( J f K , J f K ) = J g K .Proof. As in the case of the simply typed λ -calculus, this is by definition of the Church encoding. Lemma 4.16.
Let u : Str [ σ ] ⊸ . . . ⊸ Str [ σ n ] ⊸ ! Bool .For all w , . . . , w n ∈ { , } ∗ , the normal form of u w . . . w n is completely determined by the functions Φ k σ k ( w ) , . . . , Φ k σ n k ( w n ) . As a consequence, the following language is regular: { w ∈ { , } ∗ | u w . . . w −→ ∗ ! true } Proof.
We start with the case n =
1, in which u : Str [ σ ] ⊸ ! Bool . Let f : τ , f : τ and g : τ be givenby Lemma 4.13, where τ = k σ ⊸ σ k = k σ k ⊸ k σ k . For all w ∈ { , } ∗ , if w f f −→ ∗ ! h , then u w −→ ∗ b for some b ∈ { true , false } such that g h . . . h −→ ∗ b . Since f , f and g are in A λ
2, so is h (provided it is normal), and J g h . . . h K = J g K ( J h K , . . . , J h K ) by compositionality. Therefore J b K = J g K (cid:0) Φ k σ k ( w )( J f K , J f K ) , . . . , Φ k σ k ( w )( J f K , J f K ) (cid:1) thanks to the previous proposition. Since our semantics is non-trivial , i.e. J b K = J true K ⇐⇒ b = true , Φ k σ k ( w ) thus determines the normal form of u w .The result for arbitrary n ≥ n by repeatedly applying the case n = { w ∈ { , } ∗ | u w . . . w −→ ∗ ! true } can be written using onlyconditions on Φ k σ i k ( w ) ( i ∈ { , . . . , n } ), so it is the preimage of some subset of ∏ ni = End ( J σ i K ) End ( J σ i K ) by the monoid morphism w ( Φ k σ k ( w ) , . . . , Φ k σ n k ( w )) .This suffices to conclude the soundness proof. Let t : ! Str ⊸ !! Bool . Then, by Lemma 4.11, { w ∈ { , } ∗ | t ! w −→ ∗ !! true } = { w ∈ { , } ∗ | u w . . . w −→ ∗ ! true } for some u : Str [ σ ] ⊸ . . . ⊸ Str [ σ n ] ⊸ ! Bool . The regularity of this language then follows from theabove lemma.
Analyzing the our soundness proof for regular languages in EA λ reveals that fundamentally, what re-stricts the computational power is a conjunction of two facts:1. the input Str is instantiated on some types σ , . . . , σ n known in advance ;2. these σ i are morally finite data types, since they admit finite semantics.This makes it impossible to iterate over, say, the configurations of a Turing machine, since their sizedepends on the input and the type σ i cannot “grow” to accomodate data of variable size.If we stay at depth 2 in EA λ , there is no way of avoiding the second fact (one can always truncate the σ i to exponential-free types), so if we want to retrieve a larger complexity class than regular languageswithout resorting to type fixpoints, we should try to circumvent the first obstacle. That means that the σ i should vary with the input. Thus, we are led to consider that inputs should provide types : guyễn L.T.D. 27 • the encoding of an input x would be a term t x : Inp [ A x ] , for some type Inp with one parameter; • this t x would then be given as argument to a program of type ∀ α . Inp [ α ] ⊸ Bool .In other words, we are considering existential input types. Indeed, if we were to extend EA λ withexistential quantifiers , there would be an isomorphism ( ∃ α . Inp [ α ]) ⊸ Bool ∼ = ∀ α . ( Inp [ α ] ⊸ Bool ) . Remark 4.17.
In fact there is a third fact which plays a role in bridling the complexity: the shape ofthe type
Str which codes sequential iterations (but the same could be said of Church encodings of freealgebras – with such inputs one characterizes regular tree languages).For instance, let us consider as inputs circuits represented by the type ∀ X . ! X ⊸ ! ( X ⊸ X ⊸ X ) ⊸ ! ( X ⊸ X ⊗ X ) ⊸ ! X where ! X corresponds to true constants, ! ( X ⊸ X ⊸ X ) corresponds to nand gates, and ! ( X ⊸ X ⊗ X ) corresponds to duplication gates used to represent fan-out. Then instantiating this with X = Bool andthe obvious evaluation maps gives us an encoding of the circuit value problem, which is P-complete.Although this input type seems morally less legitimate than Church encodings, it is hard to pinpointprecisely why it should be rejected.
This paper started with a positive result: there exists a characterization of FP and k -FEXPTIME in µ EA λ whose statement is very simple. However, the characterization of regular languages in EA λ , which takesup the rest of the paper, could be seen as a negative result: it demonstrates the lack of expressivity of EA λ without type fixpoints. (This is the spirit of Section 4.4.) Indeed, the small class of regular languages notquite a well-behaved complexity class, e.g. it is not closed under AC reductions.That said, one can also read Theorem 1.5 as positive evidence of a connection between affine typingand automata. This connection clearly depends on the use of Church encodings – in other words, on therepresentation of strings by their iterators. This opens up two avenues for investigation: • One can search for other automata-theoretic classes of interest that can be characterized in EA λ . • On the other hand, one can hope to obtain a well-behaved sub-polynomial complexity class bychanging the representation of inputs, following the suggestions of Section 4.4.We are currently working on the first research direction, by attempting to capture classes of trans-ductions , i.e. of functions computed by automata with output. As of the time of writing, it seems likelythat in EA λ , Str ⊸ Str captures the well-known class of regular functions (see [8] for an overview ofclassical transduction classes, including regular functions), and that the class defined by !
Str ⊸ ! Str also admits an automata-theoretic characterization.As for the second one, it is the topic of a sequel paper [16] (joint work with P. Pradic) which studiesan input type inspired by finite model theory, following Hillebrand’s thesis [13]. We obtain what webelieve to be a characterization of deterministic logarithmic space (L), and manage to prove that theclass we capture is between L and NL . The reason this extension is not incorporated is that existentials can be encoded: ∃ α . τ : = ∀ β . ( ∀ α . τ ⊸ β ) ⊸ β . This sequel has been published first, although the results in the present paper were mostly obtained before. Actually, a more precise upper bound is L with an oracle for unambiguous non-deterministic logarithmic space. λ -calculus with and without type fixpoints The importance of semantics
A novelty in our approach is that we betray the original spirit of “lightlogics” such as Light Linear Logic and Elementary Linear Logic [9], which consisted in bounding thecomplexity of normalization “geometrically”, independently of types. Here: • geometry still plays an important structuring role, reflected by our use of a “truncation at depthzero” operation, which may be of independent interest; • but our fine-grained analysis also requires to take into account the influence of types throughsemantics.Though we are not the first to apply semantics to obtain inexpressivity results in light logics (cf. e.g. [5]),our recent discovery of a finite semantics of linear polymorphism (cf. the discussion below the statementof Lemma 1.7) opens up new possibilities. The above-mentioned sequel on logarithmic space is anillustration of this new way of working in EA λ and its variants: the best upper bound that we have isobtained using the effectiveness of the second-order coherence space model studied in [15]. Open questions
Aside from the perspectives already mentioned, there is an obvious question thatremains after Theorem 1.5: what about !
Str ⊸ ! k + Bool (resp. !
Str ⊸ ! k + Str ) for k ≥
1? For now,what we know about the corresponding complexity class is that: • it is contained in k -EXPTIME (resp. k -FEXPTIME), since the soundness results for µ EA λ apply a fortiori to EA λ ; • it contains ( k − ) -EXPTIME (resp. ( k − ) -FEXPTIME), by adapting the proofs given in [1].We must confess that we have no idea about what class ! Str ⊸ ! k + Bool corresponds to, let alone abouta proof strategy. Our only guesses is that the first containment is strict, and that semantics can proveuseful for this problem.
References [1] Patrick Baillot (2015):
On the expressivity of elementary linear logic: Characterizing Ptime and an exponen-tial time hierarchy . InformationandComputation241, pp. 3–31, doi:10.1016/j.ic.2014.10.005.[2] Patrick Baillot, Erika De Benedetti & Simona Ronchi Della Rocca (2018):
Characterizing polynomial andexponential complexity classes in elementary lambda-calculus . Informationand Computation 261, pp. 55–77, doi:10.1016/j.ic.2018.05.005.[3] Patrick Baillot & Alexis Ghyselen (2018):
Combining Linear Logic and Size Types for Implicit Com-plexity . In: 27th EACSL Annual Conference on Computer Science Logic (CSL 2018), pp. 9:1–9:21,doi:10.4230/LIPIcs.CSL.2018.9.[4] Alberto Carraro & Giulio Guerrieri (2014):
A Semantical and Operational Account of Call-by-Value Solv-ability . In: Foundations of Software Science and Computation Structures (FoSSaCS’14), pp. 103–118,doi:10.1007/978-3-642-54830-7_7.[5] Ugo Dal Lago & Patrick Baillot (2006):
On light logics, uniform encodings and polynomial time . Mathemat-icalStructuresinComputerScience 16(4), pp. 713–733, doi:10.1017/S0960129506005421.[6] Vincent Danos & Jean-Baptiste Joinet (2003):
Linear logic and elementary time . InformationandComputa-tion 183(1), pp. 123–137, doi:10.1016/S0890-5401(03)00010-5.[7] Simona Ronchi Della Rocca, Ugo Dal Lago & Paolo Coppola (2008):
Light Logics and the Call-by-ValueLambda Calculus . LogicalMethodsinComputerScienceVolume 4, Issue 4, doi:10.2168/LMCS-4(4:5)2008.[8] Emmanuel Filiot & Pierre-Alain Reynier (2016):
Transducers, Logic and Algebra for Functions of FiniteWords . ACMSIGLOGNews 3(3), pp. 4–19, doi:10.1145/2984450.2984453. guyễn
L.T.D. 29 [9] Jean-Yves Girard (1998):
Light Linear Logic . Information and Computation 143(2), pp. 175–204,doi:10.1006/inco.1998.2700.[10] Charles Grellois (2016):
Semantics of linear logic and higher-order model-checking . Ph.D. thesis, UniversitéDenis Diderot Paris 7. Available at https://tel.archives-ouvertes.fr/tel-01311150/ .[11] Charles Grellois & Paul-André Melliès (2015):
Finitary Semantics of Linear Logic and Higher-Order Model-Checking . In: MathematicalFoundationsofComputerScience2015-40thInternationalSymposium,MFCS2015, pp. 256–268, doi:10.1007/978-3-662-48057-1_20.[12] Giulio Guerrieri & Giulio Manzonetto (2019):
The Bang Calculus and the Two Girard’s Translations . Elec-tronicProceedingsinTheoreticalComputerScience 292, pp. 15–30, doi:10.4204/EPTCS.292.2.[13] Gerd G. Hillebrand (1994):
Finite Model Theory in the Simply Typed Lambda Calculus . Ph.D. thesis, BrownUniversity, Providence, RI, USA.[14] Gerd G. Hillebrand & Paris C. Kanellakis (1996):
On the Expressive Power of Simply Typed and Let-Polymorphic Lambda Calculi . In: Proceedingsof the11thAnnualIEEESymposiumonLogicin ComputerScience, IEEE Computer Society, pp. 253–263, doi:10.1109/LICS.1996.561337.[15] Lê Thành D˜ung Nguy˜ên (2019):
Around finite second-order coherence spaces . CoRR abs/1902.00196.[16] Lê Thành D˜ung Nguy˜ên & Pierre Pradic (2019):
From normal functors to logarithmic space queries . In:46th InternationalColloquium on Automata, Languagesand Programming(ICALP’19), pp. 123:1–123:15,doi:10.4230/LIPIcs.ICALP.2019.123.[17] Laurent Regnier (1994):
Une équivalence sur les lambda-termes . TheoreticalComputerScience 126(2), pp.281–292, doi:10.1016/0304-3975(94)90012-4.[18] Alex Simpson (2005):
Reduction in a Linear Lambda-Calculus with Applications to Operational Seman-tics . In: 16th International Conference on Term Rewriting and Applications (RTA’05), pp. 219–234,doi:10.1007/978-3-540-32033-3_17.[19] Kazushige Terui (2012):