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’enseignemen[r]

La réduction que nous venons de définir est intéressante car elle est atomique (dans le sens où elle transmet les ressources une à une) et possède tout de même une propriété de normalisa[r]

278 En savoir plus

Abstract
For overcoming the limitations of probabilistic coherence spaces which do not seem to provide natural interpretations of continuous data types such as the real line, we introduced with Pagani **and** Tasson a model of probabilistic higher or- der **computation** based on (positive) cones, **and** a class of to- tally monotone functions that we called “stable”. Then Cru- billé proved that this model is a conservative extension of the earlier probabilistic coherence space model. We continue these investigations by showing that the category of cones **and** **linear** **and** Scott-continuous functions is a model of in- tuitionistic **linear** **logic**. To define the tensor product, we use the special adjoint functor theorem, **and** we prove that this operation is an extension of the standard tensor product of probabilistic coherence spaces. We also show that these lat- ter are dense in cones, thus allowing to lift the main proper- ties of the tensor product of probabilistic coherence spaces to general cones. Finally we define in the same way an ex- ponential of cones **and** extend measurability to these new operations.

En savoir plus
Various calculi [4,12,17] have been proposed with the aim to capture aspects of service- oriented computing, from a verification or a modeling point of view but also from a formaliza- tion **and** programming point of view, which is related to our approach. However, these calculi are essentially **computation**-oriented **and** not resource-oriented. To solve these problems, we aim at using an abstract machine as a mediator between processes **and** services. The intent is to compile any process in the language of the abstract machine, which implies two strong re- quirements for the core calculus at the heart of the machine: it must be able to express query languages with support for recursion **and** aggregation, but also concurrent process languages. Our proposal is an edition calculus, that is a calculus that edits relational structures, which can abstractly represent resources **and** computations over resources. Our main contribution is to show that indeed our edition calculus is a good candidate for the abstract machine, since we can directly encode two paradigmatic languages, Datalog with negation on the query side **and** the π-calculus on the concurrent process side.

En savoir plus
The syntax of choice for LL are proof nets, graph- theoretical representation of proofs that have the advantage of exposing parallel features of deterministic **and** sequential **computation**. Its recent developments in the direction of non-deterministic differential extensions [ 9 ] reaching concurrency [ 10 ] make this kind of investigation the ideal launching pad towards extending logical interpretations of concurrent **computation**, in the sense of Curry-Howard. For now we restrain to the sequential case **and** leave multithreading for future work: here proof nets provide for a direct representation of the dependencies among different parts of the terms by means of wires (we follow the interaction net paradigm [ 11 ]). In particular effect annotations translate into several wires carrying around values: if a particular part of the program does not use a particular region, its wire will run to the next term in the evaluation order, which will be able to get **and** process the value before the preceding term has actually finished. Sequential semantics is preserved, as any evaluation of proof nets corresponds to the one of the term.

En savoir plus
Given such a machine M together with an input word u, we want to build a formula ϕ of FO[2] describing the run of M over u, such that ϕ has a model of size at most N if **and** only if M accepts u in at most N steps. Variables in ϕ will be used to describe positions of the tape of M as well as time instants in the **computation** of M . For this, we use unary predicates to encode the bits of the cell position p(x) **and** time instant t(x) described by an element x of the domain. We additionally use predicates a(x) for a in the alphabet of the machine, **and** q(x) for q in the state space of the machine to specify the content of the cell p(x) at time t(x). To avoid using formulas of rank 3, we also introduce a predicate a 0 (x) to say that cell p(x) is labelled a at time t(x) + 1. We can express that this encoding is sound, **and** specify the existence of an accepting run of the machine using a formula ϕ of rank 2. Since N can be specified in binary, **and** since |ϕ| is polynomial in the size of M , we can show that ϕ has a model of size N if **and** only if M has an accepting run of size exponential (2 n k ) in its input of size n.

En savoir plus
Contents. We define a simply typed CBPV calculus featuring positive **and** ordinary types, recursive positive types **and** with a fix- point operator for terms. Since many data types can be defined eas- ily in this language (ordinary integers, **lazy** integers, lists, streams, various kinds of finite **and** infinite trees. . . ), it widely encompasses PCF **and** is closer to a language such as FPC of [11], with the ad- ditional feature that it allows to freely combine CBV **and** CBN. We define the syntax of the language, provide a typing system **and** a simple operational semantics which is “weak” in the sense that reduction is forbidden under λs **and** within boxes (more general reductions can of course be defined but, just as in CBV, a let con- struction or new reduction rules as in [3] should be added).

En savoir plus
7 Conclusion
Girard’s so-called “GoI3” model [19] already provided an interpretation of full **linear** **logic**. However, we managed to do so in a quantitative-flavoured framework. Beyond the results presented here, the adaptation of the interaction graphs framework to deal with continu- ous dialects results in a more mature **and** complete construction. Indeed, the possibly to manage the maps at the level of the dialect through the microcosm opens new possibilities in terms of computational complexity. Indeed, while the weight monoid **and** the measure- ment of weights seem to be related to different computational paradigms **and** can be used, for instance, for representing probabilistic **computation** [34], the microcosm can be used to restrict the computational principles allowed in the model **and** characterise in this way various complexity classes [34, 33]. All the characterisations obtained considered variants of exponentials satisfying at least the contraction principle. In the more general construction explained here, we are now able to consider models of exponentials that do not satisfy this principle. In this line of work, it would be interesting to understand if one can adapt Mazza **and** Terui’s work on parsimonious lambda-calculus [27, 28, 26], **and** obtain an interaction graph model for it.

En savoir plus
6. Conclusion
We have presented the computational model of e-nets: untyped proofs-nets for classical elementary **linear** **logic**. We have shown how they characterize PTIME **computation** (Theorems 2 **and** 3), **and** more generally k-EXPTIME com- putation (Theorem 4). The main novelties are the absence of types **and** the non-affine framework. We have used types as an intermediary tool to make the representation of PTIME Turing machines more understandable, but it is also possible to directly build the e-net simulating the execution of a given ma- chine, without any reference to types. The restricted erasure power of the model requires to do some garbage management along the simulation, but it has no direct impact on the reading of the final result.

En savoir plus
any (specific) M -formula m **and** G-formula g, **and** may be thought of as describing a **computation** that first compiles the term m into a program p **and** then uses the resulting program to solve the goal g.
As noted in [21] formulas like the one above are not legal hohh formula, as only rigid formulas may occur as antecedents of a nested implication in the language hohh. On the other hand, hohh formulas are more powerful than M-formulas in other respects, as they allow occurrences of variable G formulas, which are instead forbidden in M. There is, in fact, a more fundamental difference between M (equivalently L) formulas **and** the hohh formulas of [21], that lies in the structure of terms. Specifically hohh terms may be formed as simply typed λ-terms, but are then restricted so as to rule out terms containing occurrences of (intuitionistic) implication; on the other hand, M-terms are algebraic terms where we do allow such occurrences of implication.

En savoir plus
between ! **and** . This distributive law enables us to define a colored exponen- tial = ! ◦ **and** an inductive-coinductive fixpoint lifting the corresponding constructions of our infinitary relational semantics. We then shift to the idem- potent intersection type systems of Terui [Ter12] **and** Ehrhard [Ehr12a] **and** equip them with coloring **and** an inductive-coinductive fixpoint operator Y . We also introduce a Scott colored semantics **and** we prove that it is equivalent in a precise sense with the colored **and** idempotent intersection type system just obtained. By revising Kobayashi **and** Ong’s original type system (our system differs in some key aspects from their original system, **and** is not equivalent to it) we are able to reflect the recognition of a higher-order recursion scheme by an alternating parity tree automaton just by looking at the interpretation of the higher-order recursion scheme (seen as an equivalent λ-term with fixpoint Y ) in the finitary **and** colored Scott semantics. The decidability of the local higher-order model-checking problem follows, as the interpretation of a HORS is always computed in finite time. In fact, the finiteness of the semantics has stronger implications: it allows us to prove the decidability of the selection problem, which follows from a form of regularity of the semantics: any denota- tion of a λY -term can be obtained from a finitely representable **computation**; **and** this finite representation can be formulated in the language of higher-order recursion schemes. The finitary model we obtain is close to the finitary model independently defined by Salvati **and** Walukiewicz [SW15a], **and** that they used to prove the decidability of the local higher-order model-checking problem, as well as a transfer theorem we detail on the related works (§1.2).

En savoir plus
300 En savoir plus

This article gives a higher-order notion of distributions with compact support, fol- lowing the model without higher order constructed by the first author in [14]. Indeed, only functions whose domains are finite dimensional were defined in [14], while no interpretation was given for functions whose domains are spaces of smooth functions. This latter notion relies on the basic intuition that even with a continuous **and** infinite set of input data, a program will at each **computation** use only a finite amount of data. Content **and** related work In this paper, we interpret the exponential as an inductive limit of spaces of distributions with compact support (Definition 7). Non-**linear** proofs are thus interpreted as elements of a projective limit of spaces of smooth functions. In [3], Blute, Cockett, **and** Seely construct a general interpretation of an exponential as a projective limit of more basic spaces. In [13], Kriegl **and** Michor construct the free C 8 -ring over a set X (thus a space of smooth functions) as a projective limit of spaces

En savoir plus
Concurrency **and** Effects Automatic parallelization is not the only challenge of
modern programming. Either via the internet, or even on a single computer, to- day programs live in a concurrent world. They are exchanging information with other programs **and** in the same time competing for resources. Programming models must incorporate this dimension **and** offer primitives to perform **and** control this kind of interactions. While λ-calculus is a fundamental tool in the study **and** design of functional programming languages, mainstream program- ming languages are pervaded with features that enable productive development such as support for parallelism **and** concurrency, communication primitives, im- perative references, etc. Most of them imply side-effects, which are challenging to model, to compose, **and** to reason about. Some effects, such as imperative references, are non commutative: the order of evaluation matters **and** may change the result of a **computation**. Together with parallelism, this induces a typical consequence of concurrency: non-determinism. Non determinism means that the same program, executed in the same environment, may give different **and** incompatible results. One simple example to illustrate this is a program composed of three threads in parallel accessing the same memory cell which holds an integer value. The first one tries to read the memory cell, the second one tries to write the value 0 in it, while the third one tries to write the value 1 in it. Depending on which of the writers is executed first, the reader may end up getting either 0 or 1.

En savoir plus
154 En savoir plus

This important research notwithstanding, it appears that there is still ground to cover toward canonical **and** firm foundations for concurrent **computation**. First of all, asynchronous communication does not appear to rest on solid foun- dations. Yet this communication style is easier to implement **and** more practical than the purely synchronous paradigm, so it is widespread **and** asynchronous typed process calculi have been already investigated (see [16]). Unfortunately, **linear** **logic** has not so far provided via Curry-Howard a logical account of asyn- chronous communication. The reason is that there is a glaring discrepancy between full cut-elimination in sequent calculus **and** π-calculus reduction which has not so far been addressed. On one hand, as we shall see, **linear** **logic** does support asynchronous communication, but only through the full process of cut- elimination, which indeed makes essential use of asynchronous communication. On the other hand, the π-calculus of [10] only mimics a partial cut-elimination process that only eliminates top-level cuts. Indeed, by comparison with its type system, the π-calculus lacks some necessary computational reduction rules. Some of the missing reductions, corresponding to commuting conversions, were provided in Wadler’s CP. The congruence rules that allow the extra reductions to mirror full cut-elimination, however, were rejected: in Wadler’s [37] own words, “such rules do not correspond well to our notion of **computation** on processes, so we omit them”. A set of reductions similar to that rejected by Wadler is regarded in [32] as sound relatively to a notion of “typed context bisimilarity”. The notion, however, only ensures that two “bisimilar” processes have the same input/output behaviour along their main communication channel; the inter- nal synchronization among the parallel components of the two processes is not captured **and** may differ significantly. Thus, the extensional flavor of the bisim- ilarity notion prevents it from detecting the intensionally different behaviour of the related processes, that is, how differently they communicate **and** compute.

En savoir plus
Univ Lyon, CNRS, ENS de Lyon, Universit´ e Claude-Bernard Lyon 1, LIP, F-69342, Lyon Cedex 07, France 2
ENS Paris-Saclay, France
Abstract. Several type systems have been proposed to statically control the time complexity of lambda-calculus programs **and** characterize complexity classes such as FPTIME or FEXPTIME. A first line of research stems from **linear** **logic** **and** defines type systems based on restricted versions of the ”!” modality controlling duplication. An instance of this is light **linear** **logic** for polynomial time **computation** [Girard98]. A second perspective relies on the idea of tracking the size increase between input **and** output, **and** together with a restricted use of recursion, to deduce from that time complex- ity bounds. This second approach is illustrated for instance by non-size-increasing types [Hofmann99]. However both approaches suffer from limitations. The first one, that of **linear** **logic**, has a limited in- tensional expressivity, that is to say some natural polynomial time programs are not typable. As to the second approach it is essentially **linear**, more precisely it does not allow for a non-**linear** use of functional arguments. In the present work we adress the problem of incorporating both approaches into a common type system. The source language we consider is a lambda-calculus with data-types **and** iteration, that is to say a variant of Godel’s system T. Our goal is to design a system for this language allowing both to handle non-**linear** functional arguments **and** to keep a good intensional expressivity. We illustrate our methodology by choosing the system of elementary **linear** **logic** (ELL) **and** combining it with a system of **linear** size types. We discuss the expressivity of this new type system **and** prove that it gives a characterization of the complexity classes FPTIME **and** 2k-FEXPTIME, for k ě 0.

En savoir plus
serre@liafa.jussieu.fr
Abstract
Determining for a given deterministic complete automaton the se- quence of visited states while reading a given word is the core of im- portant problems with automata-based solutions, such as approximate string matching. The main difficulty is to do this **computation** effi- ciently, especially when dealing with very large texts. Considering words as vectors **and** working on them using vectorial (parallel) operations al- lows to solve the problem faster than in **linear** time using sequential computations.

In LL, the exponential is usually thought of as the modality of duplicable information. **Linear** functions are not allowed to copy their arguments **and** are therefore very limited in terms of computational expressive power, the expo- nential allows one to define non **linear** functions which can duplicate **and** erase their arguments **and** are therefore much more powerful. This duplication **and** erasure capability seems to be due to the presence of the rules of contraction **and** weakening in LL, but this is not quite true: the genuinely infinite rule of LL is promotion which makes a proof duplicable an arbitrary number of times, **and** erasable. This fact could not be observed in LL because promotion is the only rule of LL which allows one to introduce the “!” modality: without promotion, it is impossible to build a proof object that can be cut on a contraction or a weakening rule.

En savoir plus
could imagine an isomorphism 0 ∼ = ∀a.a in a version of our proof nets which is extended with additives **and** exponentials. However, in this case 0 would not be initial.
9. Conclusions
In this paper we have investigated the relation between three different ways of presenting proofs in MLL2. First, in the sequent calculus, second, in the calculus of structures, **and** third, via proof graphs **and** expansion trees, **and** we have shown how these three presentations can be translated into each other. The main open question is now whether the identifications on proofs made by proof nets (i.e., equivalence classes of proof graphs) is the “right one”. The observations in Section 8 show that the last word on this issue is not yet spoken. It would be important, to find independent (category theoretical) axiomatizations for the proof identity in MLL2, based on purely algebraic grounds. Then one could compare this algebraic notion of proof identity for MLL2 with the syntactic one based on proof nets.

En savoir plus