From normal functors to logarithmic space queries

HAL Id: hal-02024152

https://hal.archives-ouvertes.fr/hal-02024152v2

Submitted on 30 Apr 2019

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci- entific research documents, whether they are pub- lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Distributed under a Creative Commons Attribution| 4.0 International License

To cite this version:

Lê Thành Dũng Nguyễn, Pierre Pradic. From normal functors to logarithmic space queries. 46th

International Colloquium on Automata, Languages and Programming (ICALP 2019), Jul 2019, Patras,

Greece. �10.4230/LIPIcs.ICALP.2019.123�. �hal-02024152v2�

Lê Thành D˜ ung Nguy˜ ên

LIPN, UMR 7030 CNRS, Université Paris 13, Sorbonne Paris Cité, France https://nguyentito.eu/

nltd@nguyentito.eu

Pierre Pradic

ENS de Lyon, Université de Lyon, LIP, France

University of Warsaw, Faculty of Mathematics, Informatics and Mechanics, Poland http://perso.ens-lyon.fr/pierre.pradic/

pierre.pradic@ens-lyon.fr

Abstract

We introduce a new approach to implicit complexity in linear logic, inspired by functional database query languages and using recent developments in effective denotational semantics of polymorphism.

We give the first sub-polynomial upper bound in a type system with impredicative polymorphism;

adding restrictions on quantifiers yields a characterization of logarithmic space, for which extensional completeness is established via descriptive complexity.

2012 ACM Subject Classification

Theory of computation

Linear logic; Theory of computation

→

Complexity theory and logic; Theory of computation

Finite Model Theory

Keywords and phrases

coherence spaces, elementary linear logic, semantic evaluation

Track B: Automata, Logic, Semantics, and Theory of Programming

Related Version

A full version of the paper containing the technical appendix is available at https://hal.archives-ouvertes.fr/hal-02024152.

Funding

Lê Thành D˜ ung Nguy˜ ên: Partially supported by the Elica project (ANR-14-CE25-0005).

Pierre Pradic: Partially supported by the the RAPIDO project (ANR-14-CE25-0007).

Acknowledgements

L. T. D. Nguy˜ ên wishes to thank Damiano Mazza, Thomas Seiller and Kazushige Terui for highly instructive discussions. P. Pradic thanks Alexis Ghyselen for his valuable feedback on a first draft of this paper.

1 Introduction

Machine-free complexity We pursue here a research theme advocated by Leivant [26]:

using type systems and the proofs-as-programs correspondence to define functional languages whose expressible functions are exactly those of a given complexity. This usually consists of two independent parts: soundness – all those functions admit such complexity bounds – and extensional completeness – for every algorithm with this complexity, there is an expressible program computing the same function. This is part of the general area of implicit computational complexity (ICC), whose goal is to obtain characterizations of complexity classes by programming languages, without explicit resource bounds on a machine model (other methods in ICC include, for instance, recursive function algebras).

On the other hand, descriptive complexity is closer to a declarative programming paradigm:

it consists in characterizing complexity classes as sets of queries – predicates over finite

first-order relational structures – written in some logic. (Such structures often go by the

name of finite models; see Definition 3.) The field was launched by Fagin’s result that NP

queries correspond to existential second-order logic [11]. For our purposes, an useful example

is Immerman’s characterization of deterministic logarithmic space (L) (Theorem 13).

This idea of representing inputs as finite first-order structures also appeared in the early history of ICC: Gurevich [17] showed in 1983 that in this setting, a form of primitive recursion captures L. But unlike in descriptive complexity, Gurevich considers endofunctions instead of relations and queries.

Queries in the λ -calculus Hillebrand’s PhD thesis [18] is a junction point between implicit and descriptive complexity. The idea was to represent finite models inside the simply typed λ-calculus (STλ), using them to represent the inputs to programs. By doing so, Hillebrand et al. managed to characterize P [19], PSPACE [1] and k-EXPTIME/k-EXPSPACE

[20] – the extensional completeness for the first two being established through descriptive complexity.

Keeping in mind the connections between finite model theory and relational databases, this can also be seen as using STλ as a functional language for database queries, expressive enough to admit translations from other languages such as Datalog, as is done in [21].

The present paper could then be motivated as looking for a sub-polynomial

functional query language, filling a gap in the aforementioned work.

Linear logic for ICC Here it is natural to turn to linear logic, a constructive logic born from the proofs-as-programs correspondence, in which several characterizations of sub-polynomial complexity classes have already been devised [38, 36, 7, 28, 29]. From its inception, linear logic has indeed had the ambition to “help us improve the efficiency of programs” [13, p. 3], and a landmark result in that direction was characterizing P through Light Linear Logic [16].

In this paper, we will use Elementary Linear Logic (ELL) [16, 8], which was originally introduced to capture the class ELEMENTARY

. A recent line of work by Baillot et al. [2, 3, 4]

shows that one can define, inside variants of ELL, types of programs which compute smaller complexity classes, such as P. We follow this approach, by introducing a type Inp which is essentially an abstract data type

for finite models. Our main result is (writing Bool = 1⊕ 1):

I Theorem 1. The class of queries computed by the proofs of Inp ( !!Bool in second-order Elementary Linear Logic (ELL

) is between L and NL. Furthermore, a suitable restriction on the existential witnesses in the proof gives an exact characterization of L.

Here NL stands for non-deterministic logarithmic space. Actually, we obtain a better upper bound than NL in the unrestricted case, namely the class L

which will be defined later.

But we believe that this is still not optimal:

B Conjecture 1. Even without the restriction, the class of queries obtained is exactly L.

Our characterization has a few distinctive features with respect to the previous variants of linear logic capturing logarithmic space [36, 7, 28]: it takes place in a simple pre-existing logical system, which contains only usual logical connectives, and no primitive datatypes

; at

1 k-EXPTIME(resp.k-EXPSPACE) is the class of functions which can be computed in time (resp. space)

2 ↑^k (p(n)), where pis a polynomial and n is the size of the input. (We use Knuth’s up-arrow notation [24] for iterated exponentials: 2↑^k+1(n) = 2^2↑k(n), and 2↑⁰(n) =n.)

2 That is, capturing a complexity class belowP. To be fair, Hillebrand’s thesis does define a characterization of the sub-polynomial class offirst-order queries(FO) in STλ, but this class has very little expressivity, and our work captures a class still well aboveFO.

3 This is the class of elementary recursive functions, i.e. the union overk∈Nof the classesk-EXPTIME.

4 This term is the programming language counterpart of existential formulas in logic, cf. infra.

5 Given the special status granted to unary Church integers by the “skewed iteration” rule in Schöpp’s SBAL [36], it is fair to consider them to be primitive datatypes.

the price of a more involved encoding of inputs, the Inp type. But a main novelty, in our opinion, is the unrestricted case: to our knowledge, it is the first

sub-polynomial bound in a type system with impredicative polymorphism.

This forces our approach to be significantly different to these previous works: they all exploit some form of the Geometry of Interaction (GoI) [14, 9] as a space-efficient evaluator, whereas in our case this does not work

because of impredicative quantication. In the predicative case, there is still an obstruction to the GoI: the additive connectives of linear logic. Instead, our tool of choice will be denotational semantics.

Semantic evaluation and polymorphism This is indeed the sequel to a previous paper [32]

which studied the semantics of second-order Multiplicative-Additive Linear Logic (MALL

) with applications in mind; in particular it proved that Girard’s model of MALL

in coherence spaces [12, 13] is finite and effective. In order to establish our upper complexity bounds, we will compute the denotation of a program applied to its input in the coherence space model.

This semantic evaluation technique has been very successful before for establishing complexity bounds in STλ: it is how soundness is established in the aforementioned works of Hillebrand et al., and also underlies Terui’s more recent result on the complexity of β-reduction in STλ at fixed order [39]. Beyond STλ, it has been applied to System T and PCF, see [25] and references therein. However, these applications had been confined to monomorphic type systems

until the prequel showed:

I Theorem 2 ([32]) . The languages decided by proofs of !Str ( !!Bool in ELL

, where Str is the type of ELL Church encodings of strings, are exactly the regular languages.

An analysis of the proof also suggested that to increase the expressivity

while keeping !!Bool as output, one should replace Str by an existential input type. Hence the Inp type.

To perform semantic evaluation in a polymorphic language, one needs an effective model of polymorphism, and such models are not easy to build. First, one must first restrict to a purely linear language

such as MALL

to make a non-trivial finitary semantics possible.

Even then, obstacles remain: for instance, the prequel [32] proved that no degenerate model of MALL

(in which ⊗ and ` are identified) can satisfy a desirable “constancy property”, so this excludes the Scott model of linear logic used by [39]. Girard managed to build a semantics for System F [12] which later turned out to be finite and effective for MALL

by representing types depending on type parameters as normal functors

. Although we will not

6 Excluding the characterization of regular languages in ELL2, cf. infra, but regular languages do not form a well-behaved complexity class (for instance they are not closed under uniformAC⁰reductions).

7 We will not enter into details here, but essentially, the GoI works by “following paths” inside a proof, and in our case, the length of these paths would be super-polynomial.

8 That said, there have been some uses of rather different semantic techniques for implicit complexity in presence of polymorphism, e.g. realizability [6].

9 This was also a major motivation in the work of Hillebrand et al.: they wanted to overcome limits in STλsuch as Statman’s classical result that equality cannot be defined on STλChurch integers (see the introduction to [21]). Hillebrand and Kanellakis [20] later proved that the languages decided by STλpredicates over Church-encoded strings are regular (this inspired the analogous result on ELL2).

Such restrictions seem drastic since theβ-equivalence problem for STλis not inELEMENTARY[37, 27], hinting that its computational power should be much greater. By using finite models as inputs, Hillebrand, Kanellakis and Mairson [21] manage to express allELEMENTARYqueries.

10The type∀X. X→(X→X)→Xof polymorphic Church integers – more generally, any infinite data type whose destructors are definable – has an inifinite denotation in any semantics of System F.

11A remark: the fact that ourL^ULupper bound involvesunambiguousnondeterminism, as we shall see, is related to thestabilityof linear maps in coherence spaces; stable maps are the “lower-dimensional analogue” of normal functors, and interestingly, it seems that stability is required for the construction

have to study the properties of normal functors here – the semantic groundwork has been laid in the prequel – we consider that this ingredient is crucial enough to deserve inclusion in the title.

New complexity phenomena in MALL The bottleneck for this L

bound is the complexity of an iterated composition problem: given a MALL

type A and k proofs f

, . . . , f

of A ` A, compute their composition f

◦ . . . ◦ f

. To illustrate the kind of complexity constraint induced by the linearity of the f

, consider the types Bool ⊗. . . ⊗Bool (n times) and Bool & . . . & Bool (n times). A non-linear function does not distinguish them, whereas for linear functions:

an iteration over Bool ⊗ . . . ⊗ Bool can simulate a Turing machine running in space n (minus O(1) bits for the control state);

an iteration over Bool & . . . & Bool can be computed in space O(log(nk)).

This kind of phenomenon surfaced when we tried to obtain bounds on our ELL

queries;

we are not aware of a previous mention in the literature. Coherence spaces are sensitive to this (e.g. the interpretation of ⊗ and & bit vectors have respective sizes 2

and 2n) and thus manage to give a systematic sub-polynomial (but not L) bound on iterations.

For now, we have only managed to find a logarithmic space algorithm for those iterations in very specific cases of A, subsuming the above example. These cases still leave enough room for an extensional completeness result, leading to our exact characterization of L. But even in propositional MALL, the complexity of iterations remains mysterious.

Plan of the paper In Section 2 we introduce the necessary definitions and state the main theorems. The lower bound on expressivity is established using descriptive complexity in Section 3, while our upper bounds are both proved in Section 4 via semantic evaluation.

2 Elementary Linear Logic as a query language 2.1 Linear Logic

In this paper, we assume some familiarity with the basic ideas of the proofs-as-programs paradigm and more specifically of linear logic. The formulas and the sequent calculus of second-order Multiplicative-Additive Linear Logic (MALL

) are recalled in Appendix A.

Recall that MALL

forbids using the structural rules of contraction and weakening, enforcing linearity whose computational meaning is that data cannot be duplicated or erased.

In order to allow the use of the structural rules in a controlled manner, the grammar of full Linear Logic extends the syntax of MALL

with exponential modalities !F and ?F which allow to tag duplicable assumptions and conclusions. (Second-order) Elementary Linear Logic (ELL

) corresponds to the subsystem whose rules governing the exponential connectives are given in Figure 1; this makes the principles of digging (!A ( !!A) and dereliction (!A ( A) invalid in ELL

while they are provable in full Linear Logic.

ELL

thus satisfies a stratification property: the depth of a given connective – i.e. the number of !/? modalities it is in the scope of – does not change during cut-elimination (key cut-elimination rules are also recalled in Appendix A). As a consequence, this notion of depth is of the utmost relevance for the computational complexity properties of ELL

.

of models of polymorphism based on normal functors.

(functorial promotion) ` Γ, A

` ?Γ, !A (weakening) ` Γ

` Γ, ?A (contraction) ` Γ, ?A, ?A

` Γ, ?A

Figure 1

Exponential rules for the ELL

sequent calculus. In the functorial promotion rule, when Γ =

, ?Γ stands for ?B

?B

.

LL notations When π and ρ have respective conclusions ` Γ, A and ` A

, ∆, we write cut(π, ρ) for the proof of ` Γ, ∆ consisting of a cut-rule with premises π and ρ. Given a proof π : A, !π denotes the proof of !A obtained by applying the promotion rule to π. As we formally use one-sided sequents, A

, . . . , A

` B is a notation for ` A

, . . . , A

, B.

2.2 Finite models

I Definition 3. Let Σ be a first-order relational signature, i.e. a list of relation symbols {R

, . . . , R

} with their respective arities r

, . . . , r

.

A finite model D over Σ consists of a finite set D and an interpretation R

⊆ D

for each relation symbol. It is totally ordered when R

= ≤, r

= 2 and R

is a total order.

We write FinMod(Σ) for the set of totally ordered finite models over Σ.

As an example, a possible signature for binary strings is {≤, S} with arities 2 and 1.

Finite models consist of a totally ordered set (D, ≤

) with a unary predicate S

; we interpret (D, ≤

) as the indices of the string, and S

(d) as “the dth bit is set to 1”.

I Remark 4. The “totally ordered” assumption is common in descriptive complexity (see e.g.

Theorem 13) and will be often kept implicit in the paper. Indeed, there are order-independent queries requiring a total order to be expressed.

To use finite models as inputs for ELL

programs, we represent the elements of FinMod(Σ) as proofs of an ELL

formula Inp

.

I Definition 5. We define the types with a free variable δ:

List[δ] = ∀X. !(δ ( X ( X) ( !(X ( X ) C[δ] = δ ( δ ⊗ δ W[δ] = δ ( 1 Ctx[δ] = !List[δ] ⊗ !!C[δ] ⊗ !!W[δ] Bool = 1 ⊕ 1 Rel

[δ] = δ

( Bool Given a signature Σ = {≤, R

, . . . , R

} with arities r

= 2, r

, . . . , r

, we also define:

Inp

[δ] = Ctx[δ] ⊗ O

0≤i≤k

!!Rel

[δ] Inp

= ∃δ. Inp

[δ]

We now define the encoding D of any totally ordered finite model D over Σ as a proof of Inp

[Fin(n)], where Fin(n) = 1 ⊕ . . . ⊕ 1 with n summands, n being the domain size.

Let D = (D, ≤

, R

, . . . , R

) ∈ FinMod(Σ) with Card(D) = n. Choose a bijection between D and the n proofs of Fin(n).

We represent D as a Church-encoded list of type List[Fin(n)] enumerating the n elements of Fin(n).

Each relation R

can be represented by an element of Rel

[Fin(n)].

Finally, since Fin(n) is a positive type, there are canonical elements of type C[Fin(n)]

and W[Fin(n)] implementing the structural rules.

I Definition 6. A proof π of Inp

( !!Bool defines the query which evaluates to true on

D ∈ FinMod(Σ) iff the application of π to the encoding D reduces to !!true (where true is

the proof of Bool = 1 ⊕ 1 proving the left occurrence of 1).

2.3 Complexity classes and the main theorems

For the rest of the paper, we fix a signature Σ = {R

= ≤, R

, . . . , R

} with arities r

= 2, r

. . . , r

.

As we said in the introduction, we write L (resp. NL) for the class of decision problems solvable in deterministic (resp. non-deterministic) logarithmic space. The unambiguous logarithmic space class UL [33] consists of the problems which can be solved by a NL Turing machine whose accepting runs are guaranteed to be unique: for each input, if the machine accepts, there is a single sequence of non-deterministic choices leading to the accepting state.

(So UL ⊆ NL.) L

denotes L with an UL oracle; as usual we use the Ruzzo–Simon–Tompa definition

of space-bounded oracle machines [35, §4].

We can now state our result in the unrestricted case.

I Theorem 7. The class of queries computed by the proofs of Inp

( !!Bool in ELL

is between L and L

.

It is known that NL

= NL (as noted in [23, Corollary 2], it follows from NL = coNL), so L

⊆ NL, hence the statement in the introduction. Furthermore, while NL ⊂ P, it is commonly believed that NL 6= P, so our class of queries is presumably strictly sub-polynomial.

To state the second main theorem, we now introduce a fragment of ELL

with an ad-hoc restriction on existential witnesses.

I Definition 8. The set of positive polynomial formulas PP is the subset of MALL

formulas generated by the grammar P, Q, . . . ::= 0 | 1 | X | P ⊗ Q | P ⊕ Q.

We define PP3 to be the set of formulas of the form P ⊗ (Q ( R), where P, Q, R ∈ PP.

The logic ELL

is defined by the same rules as ELL

except that we exclude the cut rule, and restrict the ∃-rule as follows: the witness (i.e. B in Figure 2) must belong to PP3.

The “cut-free” part is necessary because a cut between two ELL

proofs does not necessarily normalize into a ELL

proof. However, we do have:

I Proposition 9. Let π and ρ be ELL

proofs with respective conclusions ` Γ, A and

` A

, ∆. If A is quantifier-free, then cut(π, ρ) is in ELL

. With ELL

, we obtain an exact characterization of L:

I Theorem 10. The class of queries computed by proofs of Inp

( !!Bool in ELL

is L.

3 The lower bound: encoding logarithmic space queries

In this section, we use descriptive complexity to get the lower bound in both theorems above (so, for the second one, this is an extensional completeness proof).

3.1 Reminder: Immerman’s characterization of L

Descriptive complexity considers queries given by formulas in extensions of classical first- order logic. The first-order formulas over Σ are generated by the grammar φ, ψ, . . . ::=

R

(x

, . . . , x

) | ¬φ | φ ∨ ψ | ∃x.φ, where the x

are variables.

12A remark on notation: they would writeL^hULiinstead ofL^ULand use the latter to denote a naive notion of oracle machine. See [35, Example 1] for an example of the subtleties involved: without a careful definition,NL^NLwould includeNP.

As usual, the semantics of these formulas is specified by a “satisfaction” relation D | = φ[σ]

for D ∈ FinMod(Σ), defined by induction over φ, where σ assigns elements of the domain D of D to the free variables of φ: e.g. D | = (∃x.φ)[σ] iff D | = φ[σ + (x 7→ d)] for some d ∈ D.

Thus, when such a formula φ is closed, it defines the query D 7→ (D | = φ).

To express all logarithmic space queries, we need to extend our language of formulas with a deterministic transitive closure operator.

I Definition 11. The formulas of first-order logic with deterministic transitive closure (FO+DTC) are generated by the above grammar extended with a new clause:

φ, ψ, . . . ::= . . . | DTC

(φ) (~ x and ~ y are lists of variables of same length)

The definition of the satisfaction relation is extended with the following induction case:

D | = DTC

(φ)[σ] ⇐⇒ σ(~ x) R

σ(~ y) where

R

is the reflexive transitive closure of the binary relation R ⊆ D

× D

; D is the domain of D and ~ x, ~ y have length k;

~a R ~b ⇐⇒ D | = φ

[σ + (~ x 7→ ~a) + (~ y 7→ ~b)]

with φ

defined as φ ∧ (∀~ z. φ[~ z/~ y] ⇒ ~ z = ~ y).

I Remark 12. In the above definition, the relation R defined by φ

is deterministic, i.e. it is the graph of a partial function D

* D

, hence the name. Indeed, it is a “determinization”

of the relation defined by φ.

I Theorem 13 (Immerman [22]) . The L queries over totally ordered finite models are exactly those expressible in FO+DTC.

3.2 An encoding of FO+DTC

Thus, it suffices to compile FO+DTC formulas, by induction, to ELL

proofs. For this purpose, it is convenient to interpret formulas with free variables as relation-valued queries:

I Theorem 14. Let φ(~ x) be an FO+DTC formula with k free variables. Then there exists an ELL

proof π

of Inp[δ] ` !!Rel

[δ] such that, for all D ∈ FinMod(Σ) with a domain D of size n, cut(D, π

[Fin(n)/δ]) reduces to the encoding of {~a ∈ D

| D | = φ[~ x 7→ ~a]}.

I Corollary 15 (Lower bound for Theorem 7 and Theorem 10) . All FO+DTC queries – and therefore all L queries – over FinMod(Σ) can be computed by ELL

proofs of Inp

( Bool.

Proof. Note that Rel

[δ] ∼ = Bool, and apply a ` -rule and a ∀-rule to the ELL

proof

given by the previous theorem. J

The detailed proof of Theorem 14 is given in Appendix B. As stated before, it works by induction on the FO+DTC formula, the bulk of the work for the induction being the case φ = DTC

(ψ). The remainder of the section gives a rough summary of the ideas involved.

Let R ⊆ D

× D

, and define ψ

: Q 7→ {(x, z) | x = z ∨ (∃y : x R y ∧ y Q z)}. Then ψ

is a monotone function over P(D

× D

), a lattice of height n

+ 1 (n = Card(D)). Its least fixpoint ψ

(∅) is exactly the reflexive transitive closure of R. To compute ψ

, we use an iterator of type Nat = ∀X. !(X ( X) ( !(X ( X) derived from the List[δ].

But this only allows us to iterate linear functions. This is where we use the assumption that R is deterministic: if f

: D

* D

is the partial function associated to R, then

13The new assignments for~xand~yoverride the pre-existing ones inσ.

ψ

(Q) = {(x, z) | x = z ∨ (f

(x) defined ∧ f

(x) Q z)}. In this reformulation, the existential quantifier, which was a source of non-linearity, has disappeared: now, for each (x, z), the evaluation of (x, z) ∈ ψ

(Q) uses Q at most once, on (f

(x), z). In the end, we manage to write a function of type Rel

[δ] ( Rel

[δ] representing ψ

, which we feed to the Nat.

A not-quite-trivial step is to define a proof of Ctx[δ], !!Rel

[δ] ` !!(δ

( 1 ⊕ δ

) sending a relation φ to the partial function associated to its determinization φ

. To do so, at one point, we need to instantiate the input List[δ] at the type δ

⊗ (δ

( 1 ⊕ δ

⊕ 1); this is our most complicated existential witness, and it is in PP3. We refer the reader to Appendix B again for details.

4 The upper bounds: semantic evaluation

We now give space-efficient algorithms for queries defined by proofs of Inp

( !!Bool in ELL

(resp. ELL

). First, we analyse the shape of such a proof, to obtain alternative definitions of the same predicates involving only MALL

types and proofs. This puts us in a position to evaluate our queries in a finite, effective semantics of MALL

: the model of coherence spaces and normal functors which we recall next. Then, we quickly derive the unrestricted L

bound for Theorem 7, and finally prove L soundness for Theorem 10 thanks to a tricky combinatorial algorithm on coherence spaces.

4.1 Syntactic analysis

Purely syntactic arguments suffice to show that our ELL

queries can be captured by a kind of function algebra, defined below. Though it bears some similarities with Gurevich’s characterization of L [17] by primitive recursion on finite models, a major difference is that our functions may take arguments which are not just domain elements (that can be coded on O(log n) bits) but also higher-order data of polynomial size in n, such as relations. Indeed, linearity serves mainly to tame the complexity in presence of higher-order features, while it is mostly meaningless on first-order data.

I Definition 16. We define inductively, simultaneously for all (k + 1)-tuples (A

, . . . , A

, B) of MALL

types with at most one free type variable δ, the classes of functions C(A

, . . . , A

; B) taking as input:

a closed MALL

type T (i.e. without free variables) a list L = [τ

, . . . , τ

] of proofs of T

a k-tuple of proofs (ρ

, . . . , ρ

) with ρ

: A

[T /δ]

and returning a proof of B[T /δ] as follows:

if π is a proof of A

, . . . , A

` B, then

[(T ; L; ρ

, . . . , ρ

) 7→ cut(ρ

, . . . cut(ρ

, π[T /δ]) . . .)] ∈ C(A

, . . . , A

; B ) (projection) Π

= [(T ; L; ρ

, . . . , ρ

) 7→ ρ

] ∈ C(A

, . . . , A

; A

)

(composition) if f

∈ C(A

, . . . , A

; B

) for i ∈ {1, . . . , l} and g ∈ C(B

, . . . , B

; C), then [(T ; L; ρ) ~ 7→ g(T; L; f

(T; L; ~ ρ), . . . , f

(T ; L; ~ ρ))] ∈ C(A

, . . . , A

; C)

(iteration) if f ∈ C(A

, . . . , A

; δ ( B ( B), then

[(T ; L = [τ

, . . . , τ

]; ~ ρ) 7→ f (T ; L; ~ ρ)hτ

i ◦ . . . ◦ f (T; L; ~ ρ)hτ

i] ∈ C(A

, . . . , A

; B ( B) where

πhτi is the partial application of π : T ( B [T /δ] ( B[T /δ] to τ : T , to produce a proof of B[T /δ] ( B[T /δ];

◦ is the composition of proofs of B[T /δ] ( B[T /δ] seen as endomorphisms of B[T /δ].

I Proposition 17. Let (A

, . . . , A

, B) be a (k + 1)-tuple of MALL

types and π be an ELL

proof of ∀δ.((!List[δ] ⊗ !!A

⊗ . . . ⊗ !!A

) ( !!B). Then there exists a function f ∈ C(A

, . . . , A

; B) such that for all ρ

: A

[T /δ] (i ∈ {1, . . . , m}) and τ

, . . . , τ

: T , cut(![τ

, . . . , τ

] ⊗ !!ρ

⊗ . . . ⊗ !!ρ

, π) = !!f (T ; [τ

, . . . , τ

]; ρ

, . . . , ρ

) (where the [τ

, . . . , τ

] on the left is a Church-encoded list in ELL

of type List[T ]).

Moreover, if π is in ELL

, then there is an inductive derivation for f in which all instances of the iteration scheme use a type of accumulators in PP3: that is, they are applied to functions in C(. . . ; δ ( P ( P ) with P ∈ PP3.

Though the proof of this proposition presents no conceptual difficulty, it is cumbersome and so is relegated to Appendix C. Importantly, it is thanks to the stratification property of ELL

that the types involved in the function algebra can be taken in MALL

: the argument uses the “truncation at depth 2” operation introduced in the prequel to prove Theorem 2.

Note that they may still contain impredicative quantifications, making its finite interpretation essential to our approach.

I Remark 18. The converse also holds: one can map functions in our algebra to ELL

proofs.

This can now be specialized to the case π : Inp

( !!Bool; indeed, Inp

( !!Bool ∼ = ∀δ. !List[δ] ⊗ !!C[δ] ⊗ !!W[δ] ⊗ O

0≤i≤N

!!Rel

[δ] ( !!Bool

Our ELL

-definable (resp. ELL

-definable) queries can therefore be specified, equival- ently, by functions in C(C[δ], W[δ], Rel

[δ], . . . , Rel

[δ]; Bool). The next step is to evaluate these functions in the coherence space model.

4.2 The finite semantics of second-order MALL in coherence spaces

We recall key facts about the denotational model of MALL

in which we will carry out our semantic evaluation. A comprehensive introduction to this model for propositional MALL may be found in [15], and the extension to MALL

is taken from the prequel [32].

In this semantics, a formula/type is interpreted as a coherence space: an undirected reflexive graph, i.e. a pair X = (|X |, ¨

) of a set |X| – customarily called the web of X – and a symmetric and reflexive relation ¨

⊆ |X | × |X | – its coherence relation. Elements x, y ∈ |X| are called coherent when x ¨

y. A clique is a subset of pairwise coherent elements of |X |; we write c @ X when c is a clique of X. The denotation of a closed type A is a coherence space, and a proof/program π : A is interpreted as a clique J π K @ J A K .

J A K is defined by induction on A, the connectives ⊗, ` , &, ⊕, (−)

being mapped to operations on coherence spaces. The base case depends on an assignment of type variables.

So, if A has n type variables, J A K is actually a map from n-tuples of coherence spaces to coherence spaces. Similarly, J π K also depends on such an assignment, and one should write J π K (X

, . . . , X

) @ J A K (X

, . . . , X

). To extend the semantics to MALL

, we interpret quantifiers as sending such “(n + 1)-parameter spaces” to “n-parameter spaces”. The following proposition sums up the properties that will be necessary for our purposes.

I Proposition 19 ([32]) . Let A be a MALL

type with a single free type variable.

J A K (X) is finite, with size polynomial in the size of X when A is fixed.

J π K (X ) can be computed in logarithmic space when π : A is fixed.

Finally, we need to recall the semantic counterpart of cut-elimination, that is, composition

of morphisms. A first remark is that |X ( Y | = |X| × |Y |. So a clique c @ X ( Y can in

fact be seen as a binary relation c ⊆ |X | × |Y |. The composition of c with some c

@ Y ( Z, seen as morphisms of coherence spaces, is then none other than their relational composition.

Additionally, the coherence relation ensures the well-known fact that:

I Proposition 20. Let c @ X ( Y , c

@ Y ( Z, x ∈ |X| and z ∈ |Z |. Then there exists at most one y ∈ |Y | such that (x, y) ∈ c and (y, z) ∈ c

.

4.3 The unrestricted case: an unambiguous logarithmic space bound

In this subsection and in the next one, we abbreviate for convenience J Fin(n) K , i.e. the n-vertex coherence space with no edges, as Fin(n). So, if A is a MALL

type with a single variable δ, then J A[Fin(n)/δ] K = J A K (Fin(n)). Our main theorem here is:

I Theorem 21. Let f ∈ C(A

, . . . , A

; B). Then J f (T; L; ρ

, . . . , ρ

) K is determined by J T K , J L K = [ J τ

K , . . . , J τ

K ] (where L = [τ

, . . . , τ

]) and J ρ

K , . . . , J ρ

K . Furthermore, when f is fixed, J f (T ; L; ρ

, . . . , ρ

) K can be computed from these denotations in L

.

Proof. By structural induction on Definition 16; the first part is an immediate consequence of the functoriality/compositionality of J − K , so we focus on the complexity. We take care of the base case, where the function comes from a proof π : (A

, . . . , A

` B), with Proposition 19 and the fact that relational composition is in L. For the composition scheme, we use the closure of

L

under composition. The iteration scheme is handled by Lemma 22 below. J I Lemma 22. Let A be a MALL

type with a single type variable. Given n, k ∈ N , f

, . . . , f

@ J A ( A K (Fin(n)) and (u, v) ∈ | J A K (Fin(n))|

, whether (u, v) ∈ (f

◦ . . . ◦ f

) can be decided in UL (in the size of the input, which is polynomial

in n and k).

Proof. Thanks to Proposition 20, if v ∈ (f

◦ . . . ◦ f

)({u}) then there is a unique sequence u

= u, u

, . . . u

= v such that u

∈ f ({u

}). We successively guess the u

; at each point, we need only store (u

, u

) to check its presence in f

. This can be done by a UL Turing machine because each u

can be stored in space O(log n): indeed, | J A K (Fin(n))| has cardinality polynomial in n (Proposition 19) and there is a natural representation of its points of using O(1) variables in |Fin(n)| = {1, . . . , n}, see [32, Section IV.D]. (Notice that we do not even make use of the coherence relation of J A K (Fin(n)); its mere existence ensures

that the naive NL algorithm is actually UL.) J

The upper bound of Theorem 7 follows immediately from Theorem 21 together with:

I Lemma 23. Let D ∈ FinMod(Σ). Its ELL

encoding D : Inp

[Fin(n)] (n is the domain size of D) contains MALL

proofs of C[Fin(n)], W[Fin(n)] and Rel

[Fin(n)] (i ∈ {1, . . . , N}).

The denotations of these proofs in the coherence space model can all be computed in L.

4.4 Iterations in deterministic log space for low-complexity types

As can be seen in the proof of Theorem 21, the single crucial point where the complexity of evaluating a query does not seem to fall squarely in L is Lemma 22. By putting the

14Strictly speaking,L^ULdenotes a class of decision problems, and it is the associated class of function problemsFL^ULwhich is closed under composition (the usual proof forFLrelativizes).

15Thefiare cliques in the graph_JA(A_K(Fin(n)), which has a polynomial size innby virtue of Propos- ition 19. Note that we always havek≥1.

complexity of this iterated composition problem in L when A ∈ PP3, we will get the L soundness result for Theorem 10.

A first remark is that for A ∈ PP3, A[Fin(n)/δ] ∼ = Fin(P (n)) ⊗(Fin(Q(n)) ( Fin(R(n))) where P, Q, R are polynomials with integer coefficients. The goal becomes to show:

I Theorem 24. Let A ∼ = Fin(m) ⊗ (Fin(n) ( Fin(p)) for some m, n, p ∈ N . Given f

, . . . , f

@ J A ( A K and (u, v) ∈ | J A K |

, whether (u, v) ∈ (f

◦ . . . ◦ f

) can be decided in L.

At this point, the proofs start to involve tricky combinatorics on coherence spaces, so this final section of the paper is written for readers familiar with the coherence space model of MALL (but not necessarily its extension to MALL

). For instance we will often identify cliques f @ A ( B with linear maps from the cliques of A to the cliques of B.

We start with a lemma solving the case m = 1, generalizing the example given at the end of the introduction.

I Lemma 25. Let A = Fin(n) ( Fin(p), f

, . . . , f

@ A ( A, ν, ν

∈ |Fin(n)| and π ∈ |Fin(p)|. There exists at most one π

such that (ν

, π

) ∈ (f

◦ . . . ◦ f

)({(ν, π)}).

Furthermore, there is a logarithmic space algorithm taking n, p, f

, . . . , f

, ν, ν

, π as inputs which decides whether π

exists and, if so, finds it.

Proof. Consider the adjoint maps f

@ (Fin(n) ⊗ Fin(p)

( Fin(n) ⊗ Fin(p)

). The graph Fin(n) ⊗ Fin(p)

has n connected components, which are all cliques (of size p). These f

send cliques to (possibly empty) cliques, so for j ∈ |Fin(n)|, f

({j} × |Fin(p)|) is either (1) empty or (2) included in some {l} × |Fin(p)|, for l uniquely determined by j. This defines partial maps f c

: |Fin(n)| * |Fin(n)|: in case (1) f c

(j) is undefined, in case (2) f c

(j) = l.

This allows us to perform a backwards iteration: we define ν

= ν

and, for i = k, . . . , 1, ν

= f c

(ν

); ν

can be computed in logarithmic space. If ν

is undefined or ν

6= ν, then π

does not exist: we return false.

Otherwise, let us restrict each i-th intermediate Fin(n) ( Fin(p) to the connected component corresponding to ν

, and take the corresponding sub-cliques: for i = 1, . . . , k, f

= f

∩ (({ν

} × |Fin(p)|) × ({ν

} × |Fin(p)|)). Then either (f

◦ . . . ◦ f

)({π}) is empty, and π

does not exist; or it contains a single element, which is then π

.

Each ν

is computable in logarithmic space, so (f

, . . . , f

) also is; additionally, the computation of (f

◦ . . . ◦ f

)({π}) from (f

, . . . , f

) and π only needs to store a single point of Fin(p) in working memory, because the cliques of the latter are subsingletons. Since L is closed under L-reductions, we are done. (Making the interactive composition explicit results

in a quadratic time algorithm.) J

We would like to L-reduce the problem to the case m = 1, by determining the projection to |Fin(m)| of the unique “path” of k + 1 points corresponding to a point of the clique f

◦ . . . ◦ f

. This would involve an iteration analogous to the previous proof, but forwards instead of backwards.

But the image f

({j} × |Fin(n) ( Fin(p)|) is not necessarily connected, because {j} ×

|Fin(n) ( Fin(p)| is not a clique (though Fin(n) ( Fin(p) is a connected graph, it is not

complete). So one cannot guarantee that this image is included in some {l} × |Fin(n) (

Fin(p)|. An explicit counter-example is the interpretation of the term λ(x ⊗ g). ((g x) ⊗ . . .)

when m = n: in some sense, the first component of the output depends on both x and g

being known, not only x. However, knowing x is enough to determine what argument will be

fed to g (x itself, in this example). The intuitive idea is to propagate this backwards.

The following lemma ensures that we can always either carry on with the forwards iteration or start the backwards propagation (Π

(resp. Π

) is the projection on the first (resp. second) component):

I Lemma 26. Let c @ A ` B be a non-empty clique. Then Π

(c) is included in a connected component of A, or (non-exclusively) Π

(c) is included in a connected component of B.

Proof sketch. If Π

(u) and Π

(v) are in different connected components for u, v ∈ c, then Π

(u) and Π

(v) are coherent or equal, and all other Π

(w) are coherent or equal to at least

one of them: Π

(c) is connected with diameter ≤ 3. J

Proof of Theorem 24. We write A = Fin(m) ⊗ B and B = Fin(n) ( Fin(p). If n = 0, A ∼ = 0 and the problem is trivial and if n = 1, A ∼ = Fin(m) ⊗ Fin(p), so a simple forward propagation solves the problem. From now on, we thus assume that n > 1, which makes B connected. Let f

, . . . , f

@ A ( A, (µ, (ν, π)) ∈ |A| and (µ

, (ν

, π

)) ∈ |A|. The goal is to decide, in logarithmic space, whether (µ

, (ν

, π

)) ∈ (f

◦ . . . ◦ f

)({(µ, (ν, π))}).

Let µ

= µ. If the clique f

({(µ, (ν, π))}) is empty, then the answer is negative; else, let {µ

} × |B| be the connected component containing it. For 1 ≤ i < k, assuming that µ

is defined, then f

({µ

} × |B|) is either:

empty, and the answer is negative;

non-empty and contained in some {µ

} × |B| – this defines µ

∈ |Fin(m)| uniquely;

non-empty and disconnected.

Let f

= f

∩ (({µ

} × |B|) × ({µ

} × |B|)) for all i ≥ 1 for which µ

is defined. If the iteration reaches i = k, this means that (f

, . . . , f

) can be computed in logarithmic space, and as in Lemma 25 we can use this to L-reduce the problem to the case m = 1, so we are done. If it aborts because of emptiness, then the algorithm can immediately return false.

The remaining case is the last item above. Suppose that µ

is undefined because of disconnectedness. Let f

= f

∩ (({µ

} × |B|) × |A|); it can be seen as a clique f

@ B ( A = B

` A, with B

= Fin(n) ⊗ Fin(p)

. The assumption that Π

(f

) = f

({µ

} × |B|) is non-empty and disconnected entails, by Lemma 26, that Π

(f

) is connected. In other words Π

(f

) ⊆ {ν

} × |Fin(p)| for some ν

.

Let us apply the algorithm of Lemma 25 to the inputs n, p, f

, . . . , f

, ν, ν

, π. This can be done in logarithmic space, and the subroutine either raises a failure or gives us some π

∈ |Fin(p)|. In the former case, we can return false; in the latter, we know that (f

◦ . . . ◦ f

)({(µ, (ν, π))}) = (f

◦ . . . ◦ f

)({(µ

, (ν

, π

))}). So all we have to do is to tail-recurse on a suffix of the original input; to implement this in L, it suffices to keep a counter indicating what the current suffix is. This is a strict suffix, because µ

is always defined by construction (see above); therefore, our algorithm terminates, while maintaining a

logarithmic working space. J

I Remark 27. Fin(m) ⊗ (Fin(n) ( Fin(p)) ∼ = L

˘

L

k=1

1, and such a bicartesian MALL formula can be seen as a game where Player and Opponents alternate choices of branches. Linear implication consists in playing two games in parallel. Morally, Lemma 26 says: if it is your turn to play on both boards, then you must make a choice; and our L algorithm is mostly about scheduling a set of strategies interacting together.

5 Perspective: unrestricted L upper bound through game semantics?

In the extensional completeness proof, strikingly, the determinism of a relation corresponds

exactly to the linearity of its pre-composition operator. This is one reason for which we believe

that our class of queries in ELL

is exactly L (Conjecture 1) – or at least, that it is strictly containted in NL which corresponds to first-order logic with general transitive closure [22].

Thus, our L

bound is likely not optimal: it is widely believed that UL = NL [34, 33].

To bring down the complexity of the bottleneck – namely the iterated composition – from UL to L, bridging the intuitions of Remark 27 with a proper game semantics of full MALL

might be key. In this direction, it is known that the points of the web of a (hyper)coherence space can be seen as external positions of a game [10, 5, 30, 31]. With this point of view, the uniqueness of the intermediate points in the iteration of Lemma 22 reflects the determinism of an underlying interaction which reaches those final positions.

References

1

Serge Abiteboul and Gerd Hillebrand. Space usage in functional query languages. In Gerhard Goos, Juris Hartmanis, Jan Leeuwen, Georg Gottlob, and Moshe Y. Vardi, editors, Database Theory — ICDT ’95, volume 893, pages 439–454. Springer Berlin Heidelberg, Berlin, Heidelberg,

1995. doi:10.1007/3-540-58907-4_33.

2

Patrick Baillot. On the expressivity of elementary linear logic: Characterizing Ptime and an exponential time hierarchy. Information and Computation, 241:3–31, April 2015. doi:

10.1016/j.ic.2014.10.005.

3

Patrick Baillot, Erika De Benedetti, and Simona Ronchi Della Rocca. Characterizing poly- nomial and exponential complexity classes in elementary lambda-calculus. Information and Computation, 261:55–77, August 2018. doi:10.1016/j.ic.2018.05.005.

4

Patrick Baillot and Alexis Ghyselen. Combining Linear Logic and Size Types for Implicit Complexity. In 27th EACSL Annual Conference on Computer Science Logic (CSL 2018), pages 9:1–9:21, 2018. doi:10.4230/LIPIcs.CSL.2018.9.

5

Pierre Boudes. Projecting Games on Hypercoherences. In Automata, Languages and Pro- gramming, volume 3142, pages 257–268. Springer Berlin Heidelberg, Berlin, Heidelberg, 2004.

doi:10.1007/978-3-540-27836-8_24.

6

Ugo Dal Lago and Martin Hofmann. Realizability models and implicit complexity. Theoretical Computer Science, 412(20):2029–2047, April 2011. doi:10.1016/j.tcs.2010.12.025.

7

Ugo Dal Lago and Ulrich Schöpp. Computation by interaction for space-bounded functional programming. Information and Computation, 248:150–194, June 2016. doi:10.1016/j.ic.

2015.04.006.

8

Vincent Danos and Jean-Baptiste Joinet. Linear logic and elementary time. Information and Computation, 183(1):123–137, May 2003. doi:10.1016/S0890-5401(03)00010-5.

9

Vincent Danos and Laurent Regnier. Reversible, irreversible and optimal

Theoret- ical Computer Science, 227(1):79–97, September 1999. doi:10.1016/S0304-3975(99)00049-3.

10

Thomas Ehrhard. Parallel and serial hypercoherences. Theoretical Computer Science, 247(1):39–

81, September 2000. doi:10.1016/S0304-3975(00)00173-0.

11

Ronald Fagin. Contributions to the model theory of finite structures. PhD thesis, University of California, Berkeley, 1973.

12

Jean-Yves Girard. The system F of variable types, fifteen years later. Theoretical Computer Science, 45:159–192, January 1986. doi:10.1016/0304-3975(86)90044-7.

13

Jean-Yves Girard. Linear logic. Theoretical Computer Science, 50(1):1–101, January 1987.

doi:10.1016/0304-3975(87)90045-4.

14

Jean-Yves Girard. Geometry of Interaction 1: Interpretation of System F. In R. Ferro, C. Bonotto, S. Valentini, and A. Zanardo, editors, Studies in Logic and the Foundations of Mathematics, volume 127 of Logic Colloquium ’88, pages 221–260. Elsevier, January 1989.

15

Jean-Yves Girard. Linear logic: its syntax and semantics. In Jean-Yves Girard, Yves Lafont,

and Laurent Regnier, editors, Advances in Linear Logic, volume 222 of London Mathematical

Society Lecture Notes. Cambridge University Press, 1995.

16

Jean-Yves Girard. Light Linear Logic. Information and Computation, 143(2):175–204, June 1998. doi:10.1006/inco.1998.2700.

17

Yuri Gurevich. Algebras of feasible functions. In 24th Annual Symposium on Foundations of Computer Science (FOCS 1983), pages 210–214, Tucson, AZ, USA, November 1983. doi:

10.1109/SFCS.1983.5.

18

Gerd G. Hillebrand. Finite Model Theory in the Simply Typed Lambda Calculus. PhD thesis, Brown University, Providence, RI, USA, 1994.

19

Gerd G. Hillebrand and Paris C. Kanellakis. Functional Database Query Languages As Typed Lambda Calculi of Fixed Order (Extended Abstract). In Proceedings of the Thirteenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, PODS ’94, pages 222–231, New York, NY, USA, 1994. ACM. doi:10.1145/182591.182615.

20

Gerd G. Hillebrand and Paris C. Kanellakis. On the Expressive Power of Simply Typed and Let-Polymorphic Lambda Calculi. In Proceedings, 11th Annual IEEE Symposium on Logic in Computer Science, New Brunswick, New Jersey, USA, July 27-30, 1996, pages 253–263. IEEE

Computer Society, 1996. doi:10.1109/LICS.1996.561337.

21

Gerd G. Hillebrand, Paris C. Kanellakis, and Harry G. Mairson. Database Query Languages Embedded in the Typed Lambda Calculus. Information and Computation, 127(2):117–144, June 1996. doi:10.1006/inco.1996.0055.

22

Neil Immerman. Languages that Capture Complexity Classes. SIAM Journal on Computing, 16(4):760–778, August 1987. doi:10.1137/0216051.

23

Neil Immerman. Nondeterministic Space is Closed under Complementation. SIAM Journal on Computing, 17(5):935–938, October 1988. doi:10.1137/0217058.

24

Donald E. Knuth. Mathematics and computer science: Coping with finiteness. Science, 194(4271):1235–1242, 1976. doi:10.1126/science.194.4271.1235.

25

Lars Kristiansen. Higher Types, Finite Domains and Resource-bounded Turing Machines.

Journal of Logic and Computation, 22(2):281–304, April 2012. doi:10.1093/logcom/exq009.

26

Daniel Leivant. Reasoning about functional programs and complexity classes associated with type disciplines. In 24th Annual Symposium on Foundations of Computer Science (FOCS 1983), pages 460–469, Tucson, AZ, USA, November 1983. doi:10.1109/SFCS.1983.50.

27

Harry G. Mairson. A simple proof of a theorem of Statman. Theoretical Computer Science, 103(2):387–394, September 1992. doi:10.1016/0304-3975(92)90020-G.

28

Damiano Mazza. Simple Parsimonious Types and Logarithmic Space. In 24th EACSL Annual Conference on Computer Science Logic (CSL 2015), pages 24–40, 2015. doi:10.4230/LIPIcs.

CSL.2015.24.

29

Damiano Mazza and Kazushige Terui. Parsimonious Types and Non-uniform Computation. In Automata, Languages, and Programming, Lecture Notes in Computer Science, pages 350–361.

Springer, Berlin, Heidelberg, July 2015. doi:10.1007/978-3-662-47666-6_28.

30

Paul-André Melliès. Sequential algorithms and strongly stable functions. Theoretical Computer Science, 343(1):237–281, October 2005. doi:10.1016/j.tcs.2005.05.015.

31

Paul-André Melliès. On dialogue games and coherent strategies. In Simona Ronchi Della Rocca, editor, Computer Science Logic 2013 (CSL 2013), pages 540–562, 2013. doi:10.4230/

LIPIcs.CSL.2013.540.

32

Lê Thành D˜ ung Nguy˜ ên. Around finite second-order coherence spaces. CoRR, abs/1902.00196, 2019. arXiv:1902.00196.

33

A. Pavan, Raghunath Tewari, and N. V. Vinodchandran. On the power of unambigu- ity in log-space. computational complexity, 21(4):643–670, December 2012. doi:10.1007/

s00037-012-0047-3.

34

K. Reinhardt and E. Allender. Making Nondeterminism Unambiguous. SIAM Journal on Computing, 29(4):1118–1131, January 2000. doi:10.1137/S0097539798339041.

35

Walter L. Ruzzo, Janos Simon, and Martin Tompa. Space-bounded hierarchies and probabilistic computations. Journal of Computer and System Sciences, 28(2):216–230, April 1984. doi:

10.1016/0022-0000(84)90066-7.

36

Ulrich Schöpp. Stratified Bounded Affine Logic for Logarithmic Space. In 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007), pages 411–420, July 2007.

doi:10.1109/LICS.2007.45.

37

Richard Statman. The typed

Theoretical Computer Science, 9(1):73–81, July 1979. doi:10.1016/0304-3975(79)90007-0.

38

Kazushige Terui. Proof nets and boolean circuits. In 19th IEEE Symposium on Logic in Computer Science (LICS 2004), 14-17 July 2004, Turku, Finland, Proceedings, pages 182–191, 2004. doi:10.1109/LICS.2004.1319612.

39

Kazushige Terui. Semantic Evaluation, Intersection Types and Complexity of Simply Typed Lambda Calculus. In 23rd International Conference on Rewriting Techniques and Applications (RTA’12), pages 323–338, 2012. doi:10.4230/LIPIcs.RTA.2012.323.

A The sequent calculus of Linear Logic

The formulas of MALL

are given by the grammar

A, B := X | X

| 1 | ⊥ | A ⊗ B | A ` B | 0 | > | A ⊕ B | A & B | ∀X. A | ∃X. B

where X belongs to a fixed countable set of variables. ELL

formulas are given by an extension of the previous grammar with the exponential modalities !/?.

A, B := · · · | !A | ?A

Customary notations for duality and linear implication are recalled in Figure 3 and the deduction rules for MALL

one-sided sequents are given in Figure 2. ELL

proofs additionally allow for the rules recalled in Figure 1 (in Section 2).

(ax-rule)

` A, A

(cut rule) ` Γ, A ` A

, ∆

` Γ, ∆ (exchange rule) ` Γ, A, B, ∆

` Γ, B, A, ∆

(⊗-rule) ` Γ, A ` B, ∆

` Γ, A ⊗ B, ∆ ( ` -rule) ` Γ, A, B

` Γ, A ` B (⊥-rule) ` Γ

` Γ, ⊥ (1-rule)

` 1

(⊕-rule) ` Γ, A

` Γ, A

⊕ A

fori∈ {1,2}

(&-rule) ` Γ, A ` Γ, B

` Γ, A & B (>-rule)

` Γ, >

(∃-rule) ` Γ, A[B/X]

` Γ, ∃X. A (∀-rule) ` Γ, A

` Γ, ∀X. A

Figure 2

Rules for the MALL

sequent calculus (there is no rule for 0).

A proof is called cut-free if there is no occurence of the cut rule. Cut-free proofs of propositional formulas satisfy the subformula property. Therefore, from a quick syntactic analysis, it follows that there are exactly two cut-free proofs ` Bool.

There is a standard rewriting system for eliminating the cut rules for both MALL

and

ELL

, which can be shown to be terminating and confluent up to some natural commutating

conversions. The process of computing a normal form is called cut-elimination. We recall

in Figure 4 the key reductions involved.