On the unity of logic

AbstractNous présentons un calcul des séquents unifié, commun aux logiques classique, intuitionniste et linéaire. La principale nouveautéest que les logiques classique, intuitionniste et linéaire apparaissent comme des fragments, c'estádire comme des classes particuliéres de formules et de séquents. Par exemple la démonstration d'unénoncéintuitionniste pourra utiliser des lemmes classiques ou intuitionnistes sans limitation: simplement aprèsélimination des coupures, la démonstration se fera entièrement dans le fragment intuitionniste, ce qui est superficiellement assurépar la propriétéde la sous-formule (seulement des formules intuitionnistes sont utilisées) et plus profondément par un traitement très rigoureux des règles structurelles. Cette approche est radicalement différente de l'approche habituelle qui consiste tout bonnementàchanger la règle du jeu quand on veut changer de logique, c'estàdire de style de séquent: ici il n'y a plus qu'une seule logique, qui au grédes utilisation peut apparaître classique, intuitionniste ou linéaire

Extending the theory of Owicki and Gries with a logic of progress

This paper describes a logic of progress for concurrent programs. The logic is based on that of UNITY, molded to fit a sequential programming model. Integration of the two is achieved by using auxiliary variables in a systematic way that incorporates program counters into the program text. The rules for progress in UNITY are then modified to suit this new system. This modification is however subtle enough to allow the theory of Owicki and Gries to be used without change

On the unity of logic

Projet FORMELRésumé disponible dans le fichier PD

Dynamic UNITY

Dynamic distributed systems, where a changing set of communicating processes must interoperate to accomplish particular computational tasks, are becoming extremely important. Designing and implementing these systems, and verifying the correctness of the designs and implementations, are difficult tasks. The goal of this thesis is to make these tasks easier. This thesis presents a specification language for dynamic distributed systems, based on Chandy and Misra's UNITY language. It extends the UNITY language to enable process creation, process deletion, and dynamic communication patterns. The thesis defines an execution model for systems specified in this language, which leads to a proof logic similar to that of UNITY. While extending UNITY logic to correctly handle systems with dynamic behavior, this logic retains the familiar UNITY operators and most of the proof rules associated with them. The thesis presents specifications for three example dynamic distributed systems to demonstrate the use of the specification language, and full correctness proofs for two of these systems and a partial correctness proof for the third to demonstrate the use of the proof logic. The thesis details a method for determining whether a system in the specification language can be transformed into an implementation in a standard programming language, as well as a method for performing this transformation on those specifications that can. This guarantees a correct implementation for any specification that can be so transformed

UNITY and Büchi automata

UNITY is a model for concurrent specifications with a complete logic for proving progress properties of the form ``$P$ leads to $Q$''. UNITY is generalized to U-specifications by giving more freedom to specify the steps that are to be taken infinitely often. In particular, these steps can correspond to non-total relations. The generalization keeps the logic sound and complete. The paper exploits the generalization in two ways. Firstly, the logic remains sound when the specification is extended with hypotheses of the form ``$F$ leads to $G$''. As the paper shows, this can make the logic incomplete. The generalization is used to show that the logic remains complete, if the added hypotheses ``$F$ leads to $G$'' satisfy ``$F$ unless $G$''. The main result extends the applicability and completeness of UNITY logic to proofs that a given concurrent program satisfies any given formula of LTL, linear temporal logic, without the next-operator which is omitted because it is sensitive to stuttering. For this purpose, the program, written as a UNITY program, is extended with a number of boolean variables. The proof method relies on implementing the LTL formula, i.e., restricting the specification in such a way that only those runs remain that satisfy the formula. This result is a variation of the classical construction of a B\"uchi automaton for a given LTL formula that accepts precisely those runs that satisfy the formula

Call-by-name, call-by-value, call-by-need and the linear lambda calculus

this paper is a minor refinement of one previously presented by Wadler [41,42], which is based on Girard's successor to linear logic, the Logic of Unity [15]. A similar calculus has been devised by Plotkin and Barber [6]. In many presentations of logic a key role is played by the structural rules: contraction provides the only way to duplicate an assumption, while weakening provides the only way to discard one. In linear logic [14], the presence of contraction or weakening is revealed in a formula by the presence of the `of course' connective, written `!'. The Logic of Unity [15] takes this separation one step further by distinguishing linear assumptions, which one cannot contract or weaken, from nonlinear or intuitionistic assumptions, which one can. Corresponding to Girard's first translation we define a mapping ffi from the call-byname to the linear calculus and show that this mapping is sound, in that M \Gamma\Gamma\Gamma\Gamma

CODEWEAVE: exploring fine-grained mobility of code

This paper is concerned with an abstract exploration of code mobility constructs designed for use in settings where the level of granularity associated with the mobile units exhibits significant variability. Units of mobility that are both finer and coarser grained than the unit of execution are examined. To accomplish this, we take the extreme view that every line of code and every variable declaration are potentially mobile, i.e., it may be duplicated or moved from one program context to another on the same host or across the network. We also assume that complex code assemblies may move with equal ease. The result is CODEWEAVE, a model that shows how to develop new forms of code mobility, assign them precise meaning, and facilitate formal verification of programs employing them. The design of CODEWEAVE relies greatly on Mobile UNITY, a notation and proof logic for mobile computing. Mobile UNITY offers a computational milieu for examining a wide range of constructs and semantic alternatives in a clean abstract setting, i.e., unconstrained by compilation and performance considerations traditionally associated with programming language design. Ultimately, the notation offered by CODEWEAVE is given exact semantic definition by means of a direct mapping to the underlying Mobile UNITY model. The abstract and formal treatment of code mobility offered by CODEWEAVE establishes a technical foundation for examining competing proposals and for subsequent integration of some of the mobility constructs both at the language level and within middleware for mobility