Showing papers in "Information & Computation in 2000"

On Full Abstraction for PCF

Abstract: We present an order-extensional, order (or inequationally) fully abstract model for Scott's language pcf. The approach we have taken is very concrete and in nature goes back to S. C Kleene (1978, in “General Recursion Theory II, Proceedings of the 1977 Oslo Symposium,” North-Holland, Amsterdam) and R. O. Gandy (1993, “Dialogues, Blass Games, Sequentiality for Objects of Finite Type,” unpublished manuscript) in one tradition, and to G. Kahn and G. D. Plotkin (1993, Theoret. Comput. Sci.121, 187?278) and G. Berry and P.-L. Curien (1982, Theoret. Comput. Sci.20, 265?321) in another. Our model of computation is based on a kind of game in which each play consists of a dialogue of questions and answers between two players who observe the following principles of civil conversation: 1.Justification. A question is asked only if the dialogue at that point warrants it. An answer is proffered only if a question expecting it has already been asked. 2.Priority. Questions pending in a dialogue are answered on a last-asked-first-answered basis. This is equivalent to Gandy's no-dangling-question-mark condition. We analyze pcf-style computations directly in terms of partial strategies based on the information available to each player when he or she is about to move. Our players are required to play an innocent strategy: they play on the basis of their view which is that part of the history that interests them currently. Views are continually updated as the play unfolds. Hence our games are neither history-sensitive nor history-free. Rather they are view-dependent. These considerations give expression to what seems to us to be the nub of pcf-style higher-type sequentiality in a (dialogue) game-semantical setting.

Full Abstraction for PCF

Abstract: An intensional model for the programming language PCF is described in which the types of PCF are interpreted by games and the terms by certain history-free strategies. This model is shown to capture definability in PCF. More precisely, every compact strategy in the model is definable in a certain simple extension of PCF. We then introduce an intrinsic preorder on strategies and show that it satisfies some striking properties such that the intrinsic preorder on function types coincides with the pointwise preorder. We then obtain an order-extensional fully abstract model of PCF by quotienting the intensional model by the intrinsic preorder. This is the first syntax-independent description of the fully abstract model for PCF. (Hyland and Ong have obtained very similar results by a somewhat different route, independently and at the same time.) We then consider the effective version of our model and prove a universality theorem: every element of the effective extensional model is definable in PCF. Equivalently, every recursive strategy is definable up to observational equivalence.

Algorithmic Analysis of Programs with Well Quasi-ordered Domains

Abstract: Over the past few years increasing research effort has been directed towards the automatic verification of infinite-state systems. This paper is concerned with identifying general mathematical structures which can serve as sufficient conditions for achieving decidability. We present decidability results for a class of systems (called well-structured systems) which consist of a finite control part operating on an infinite data domain. The results assume that the data domain is equipped with a preorder which is a well quasi-ordering, such that the transition relation is “monotonic” (a simulation) with respect to the preorder. We show that the following properties are decidable for well-structured systems: ?Reachability: whether a certain set of control states is reachable. Other safety properties can be reduced to the reachability problem. ?Eventuality: whether all executions eventually reach a given set of control states (represented as AFp in CTL). ?Simulation: whether there exists a simulation between a finite automaton and a well-structured system. The simulation problem will be shown to be decidable in both directions. We also describe how these general principles subsume several decidability results from the literature about timed automata, relational automata, Petri nets, and lossy channel systems.

Completeness of Kozen's axiomatisation of the propositional m-calculus

Abstract: Propositional μ-calculus is an extension of the propositional modal logic with the least fixpoint operator. In the paper introducing the logic Kozen posed a question about completeness of the axiomatisation which is a small extension of the axiomatisation of the model system K. It is shown that this axiomatisation is complete.

Process rewrite systems

Abstract: Many formal models for infinite-state concurrent systems are equivalent to special classes of rewrite systems. We classify these models by their expressiveness and define a hierarchy of classes of rewrite systems. We show that this hierarchy is strict with respect to bisimulation equivalence. The most general and most expressive class of systems in this hierarchy is called process rewrite systems (PRS). They subsume Petri nets, PA-processes, and pushdown processes and are strictly more expressive than any of these. Intuitively, PRS can be seen as an extension of Petri nets by subroutines that can return a value to their caller. We show that the reachability problem is decidable for PRS. It is even decidable if there is a reachable state that satisfies certain properties that can be encoded in a simple logic. Thus, PRS are more expressive than Petri nets, but not Turing-powerful.

Compositionality in Dataflow Synchronous Languages

Abstract: Modularity is advocated as a solution for the design of large systems; the mathematical translation of this concept is often that of compositionality. This paper is devoted to the issues of compositionality for modular code generation, in dataflow synchronous languages. As careless reuse of object code in new or evolving system designs fails to work, we first concentrate on what are the additional features needed to abstract programs for the purpose of code generation: we show that a central notion is that of scheduling specification as resulting from a causality analysis of the given program. Using this notion, we study separate compilation for synchronous programs. An entire section is devoted to the formal study of causality and scheduling specifications. Then we discuss the issue of distributed implementation using an asynchronous medium of communication. Our main results are that it is possible to characterize those synchronous programs which can be distributed on an asynchronous architecture without loosening semantic properties. Two new notions of endochrony and isochrony are introduced for this purpose. As a result, we derive a theory for synthesizing additional schedulers and protocols needed to guarantee the correctness of distributed code generation. Corresponding algorithms are implemented in the framework of the DC+ common format for synchronous languages, and the V4 release of the SIGNAL language.

Structural cut elimination

Abstract: We present new variants of known proofs of cut elimination for intuitionistic and classical sequent calculi. In both cases the proofs proceed by three nested structural inductions, avoiding the explicit use of multi-sets and termination measures on sequent derivations. This makes them amenable to elegant and concise representations in LF, which are given in full detail.

Model-checking of correctness conditions for concurrent objects

Abstract: The notions of serializability, linearizability, and sequential consistency are used in the specification of concurrent systems. We show that the model checking problem for each of these properties can be cast in terms of the containment of one regular language in another regular language shuffled using a semicommutative alphabet. The three model checking problems are shown to be, respectively, in Pspace, in Expspace, and undecidable.

What is a “good” encoding of guarded choice?

Abstract: The π -calculus with synchronous output and mixed-guarded choices is strictly more expressive than the π -calculus with asynchronous output and no choice. This result was recently proved by C. Palamidessi and, as a corollary, she showed that there is no fully compositional encoding from the former into the latter that preserves divergence-freedom and symmetries. This paper argues that there are nevertheless “good” encodings between these calculi. In detail, we present a series of encodings for languages with (1) input-guarded choice, (2) both input- and output-guarded choice, and (3) mixed-guarded choice, and investigate them with respect to compositionality and divergence-freedom. The first and second encoding satisfy all of the above criteria, but various “good” candidates for the third encoding—inspired by an existing distributed implementation—invalidate one or the other criterion. While essentially confirming Palamidessi's result, our study suggests that the combination of strong compositionality and divergence-freedom is too strong for more practical purposes.

A timed concurrent constraint language

Abstract: We study a timed concurrent constraint language, called tccp , which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp : We define a fully abstract semantics for a sublanguage of tccp , called ccpm , which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp .

Combining deduction and model checking into Tableaux and algorithms for converse-PDL

Abstract: This paper presents a prefixed tableaux calculus for Propositional Dynamic Logic with Converse based on a combination of different techniques such as prefixed tableaux for modal logics and model checkers for μ-calculus. We prove the correctness and completeness of the calculus and illustrate its features. We also discuss the transformation of the tableaux method (naively NEXPTIME) into an EXPTIME algorithm.

Decoding Choice Encodings

Abstract: We study two encodings of the asynchronous ?-calculus with input-guarded choice into its choice-free fragment. One encoding is divergence-free, but refines the atomic commitment of choice into gradual commitment. The other preserves atomicity, but introduces divergence. The divergent encoding is fully abstract with respect to weak bisimulation, but the more natural divergence-free encoding is not. Instead, we show that it is fully abstract with respect to coupled simulation, a slightly coarser?but still coinductively defined?equivalence that does not enforce bisimilarity of internal branching decisions. The correctness proofs for the two choice encodings introduce a novel proof tech- nique exploiting the properties of explicit decodings from translations to source terms.

An Algebraic Framework for Urgency

Abstract: A sub-class of timed automata known as timed automata with deadlines was presented. Parallel composition and other operators were defined according to 'orthogonality' principal, for timed process algebras and hybrid automata. The compositional description methods that are based on 'flexible' composition rules that relax urgency constraints to preserve time reactivity was also studied.

On the expressiveness of Linda coordination primitives

Abstract: We introduce a process algebra containing the coordination primitives of Linda (asynchronous communication via a shared data space, read operation, nonblocking test operators on the shared space). We compare two possible semantics for the output operation: the former, that we call ordered, defines the output as an operation that returns when the message has reached the shared data space; the latter, that we call unordered, returns just after sending the message to the tuple space. The process algebra under the ordered semantics is Turing powerful, as we are able to program any random access machine. The main result of the paper is that the process algebra under the unordered semantics is not Turing powerful. This result is achieved by resorting to a net semantics in terms of contextual nets (P/T nets with inhibitor and read arcs) and by showing that there exists a deadlock-preserving simulation of such nets by finite P/T nets, a formalism where termination is decidable.

Verification by Augmented Finitary Abstraction

Abstract: The paper deals with the proof method of verification by finitary abstraction (VFA), which presents a feasible approach to the verification of the temporal properties of (potentially infinite-state) reactive systems. The method consists of a two-step process by which, in a first step, the system and its temporal specification are jointly abstracted into a finite-state system and a finite-state specification. The second step uses model checking to establish the validity of the abstracted property over the abstracted system. The VFA method can be considered a viable alternative to verification by temporal deduction which, up to now, has been the main method generally applicable for verification of infinite-state systems. The paper presents a general recipe for the joint abstraction, which is shown to be sound, where soundness means that validity over the abstract system implies validity over the concrete (original) system. To make the method applicable for the verification of liveness properties, pure abstraction is sometimes no longer adequate. We show that by augmenting the system by an appropriate (and standardly constructible) progress monitor, we obtain an augmented system, whose computations are essentially the same as the original system, and which may now be abstracted while preserving the desired liveness properties. We refer to the extended method as verification by augmented abstraction (VAA). We then proceed to show that the VAA method is sound and complete for proving all properties expressible by temporal logic (including both safety and liveness). Completeness establishes that whenever the property is valid, there exists a finitary abstraction which abstracts the system, augmented by an appropriate progress monitor, into a finite-state system which validated the abstracted property.

Uniform Generation of NP-Witnesses Using an NP-Oracle

Abstract: A uniform generation procedure for NP is an algorithm that, given any input in a fixed NP-language, outputs a uniformly distributed NP-witness for membership of the input in the language. We present a uniform generation procedure for NP that runs in probabilistic polynomial time with an NP-oracle. This improves upon results of M. Jerrum et al. (1986, Theoret. Comput. Sci.43, 169?188), which either require a ?P2 oracle or obtain only almost uniform generation. Our procedure utilizes ideas originating in the works of M. Sipser, and L. Stockmeyer (respectively, 1983, in Proceedings of the 15th Annual Symposium on the Theory of Computing, ACM, New York), and Jerrum et al. (1986).

Higher order unification via explicit substitutions

Abstract: Higher order unification is equational unification for βη-conversion. But it is not first order equational unification, as substitution has to avoid capture. Thus, the methods for equational unification (such as narrowing) built upon grafting (i.e., substitution without renaming) cannot be used for higher order unification, which needs specific algorithms. Our goal in this paper is to reduce higher order unification to first order equational unification in a suitable theory. This is achieved by replacing substitution by grafting, but this replacement is not straightforward as it raises two major problems. First, some unification problems have solutions with grafting but no solution with substitution. Then equational unification algorithms rest upon the fact that grafting and reduction commute. But grafting and βη-reduction do not commute in λ-calculus and reducing an equation may change the set of its solutions. This difficulty comes from the interaction between the substitutions initiated by βη-reduction and the ones initiated by the unification process. Two kinds of variables are involved: those of βη-conversion and those of unification. So, we need to set up a calculus which distinguishes between these two kinds of variables and such that reduction and grafting commute. For this purpose, the application of a substitution of a reduction variable to a unification one must be delayed until this variable is instantiated. Such a separation and delay are provided by a calculus of explicit substitutions. Unification in such a calculus can be performed by well-known algorithms such as narrowing, but we present a specialised algorithm for greater efficiency. At last we show how to relate unification in λ-calculus and in a calculus with explicit substitutions. Thus, we come up with a new higher order unification algorithm which eliminates some burdens of the previous algorithms, in particular the functional handling of scopes. Huet's algorithm can be seen as a specific strategy for our algorithm, since each of its steps can be decomposed into elementary ones, leading to a more atomic description of the unification process. Also, solved forms in λ-calculus can easily be computed from solved forms in λσ-calculus.

Building Decision Procedures for Modal Logics from Propositional Decision Procedures

Abstract: The goal of this paper is to propose a new technique for developing decision procedures for propositional modal logics. The basic idea is that propositional modal decision procedures should be developed on top of propositional decision procedures. As a case study, we consider satisfiability in modal K(m), that is modal K with m modalities, and develop an algorithm, called KSAT, on top of an implementation of the Davis?Putnam?Longemann?Loveland procedure. KSAT is thoroughly tested and compared with various procedures and in particular with the state-of-the-art tableau-based system KRIS. The experimental results show that KSAT outperforms KRIS and the other systems of orders of magnitude, highlight an intrinsic weakness of tableau-based decision procedures, and provide partial evidence of a phase transition phenomenon for K(m).

Zero-safe nets: comparing the collective and individual token approaches

Abstract: The main feature of zero-safe nets is a primitive notion of transition synchronization . To this aim, besides ordinary places, called stable places, zero-safe nets are equipped with zero places, which in an observable marking cannot contain any token. This yields the notion of transaction : A basic atomic computation, which may use zero tokens as triggers, but defines an evolution between observable markings only. The abstract counterpart of a generic zero-safe net B consists of an ordinary P/T net whose places are the stable places of B and whose transitions represent the transactions of B . The two nets offer the refined and the abstract models of the same system, respectively, where the former can be much smaller than the latter, because of the transition synchronization mechanism. Depending on the chosen approach— collective vs individual token philosophy —two notions of transaction may be defined, each leading to different operational and abstract models. Their comparison is fully discussed on the basis of a multicasting system example. In the second part of the paper, we make use of category theory to analyze and motivate our framework. More precisely, the two operational semantics of zero-safe nets are characterized as adjunctions, and the derivation of abstract P/T nets as coreflections.

Apple tasting

Abstract: In the standard on-line model the learning algorithm tries to minimizethe total number of mistakes made in a series of trials. On each trial the learner sees an instance, makes a prediction of its classification, then finds out the correct classification. We define a natural variant of this model (''apple tasting'') whereu* the classes are interpreted as the good and bad instances, * the prediction is interpreted as accepting or rejecting the instance,and * the learner gets feedback only when the instance is accepted. We use two transformations to relate the apple tasting model to an enhanced standard model where false acceptances are counted separately from false rejections. We apply our results to obtain a good general-purpose apple tasting algorithm as well as nearly optimal apple tasting algorithms for a variety of standard classes, such as conjunctions and disjunctions of n boolean variables. We also present and analyze a simpler transformation useful when the instances are drawn at random rather than selected by an adversary.

Games and full abstraction for FPC

Abstract: A new category of games is developed which improves over existing such categories in that it interprets sums as well as products, function spaces, and recursive types. A model of FPC, a sequential functional language with just this type structure, is described and shown to be fully abstract.

Type reconstruction for linear p-calculus with I/O subtyping

Abstract: Powerful concurrency primitives in recent concurrent languages and thread libraries provide great flexibility about implementation of high-level features like concurrent objects. However, they are so low-level that they often make it difficult to check global correctness of programs or to perform nontrivial code optimization, such as elimination of redundant communication. In order to overcome those problems, advanced type systems for input-only/output-only channels and linear (use-once) channels have been recently studied, but the type reconstruction problem for those type systems remained open, and therefore, their applications to concurrent programming languages have been limited. In this paper, we develop type reconstruction algorithms for variants of Kobayashi, Pierce, and Turner's linear channel type system with Pierce and Sangiorgi's subtyping based on input-only/output-only channel types and prove correctness of the algorithms. To our knowledge, no complete type reconstruction algorithm has been previously known for those type systems. We have implemented one of the algorithms and incorporated it into the compiler of the concurrent language HACL. This paper also shows some experimental results on the algorithm and its application to compile-time optimizations.

Specification in CTL + Past for verification in CTL

Abstract: We describe PCTL, a temporal logic extending CTL with connectives allowing to refer to the past of a current state. This incorporates the new N, “from now on,” combinator we recently introduced. PCTL has a branching future, but a determined, finite, and cumulative past. We argue this is the right choice for a semantical framework and show this through an extensive example. We investigate the feasibility of verification with PCTL and demonstrate how a translation-based approach allows model-checking specifications written in NCTL, a fragment of PCTL.

Bisimilarity of Open Terms

Abstract: Traditionally, in process calculi, relations over open terms, i.e., terms with free process variables, are defined as extensions of closed-term relations: two open terms are related if and only if all their closed instantiations are related. Working in the context of bisimulation, in this paper we study a different approach; we define semantic models for open terms, so-called conditional transition systems, and define bisimulation directly on those models. It turns out that this can be done in at least two different ways, one giving rise to De Simone's formal hypothesis bisimilarity and the other to a variation which we call hypothesis-preserving bisimilarity (denoted ~fh and ~hp, respectively). For open terms, we have (strict) inclusions ~fh c ~hp c ~ci (the latter denoting the standard “closed instance” extension); for closed terms, the three coincide. Each of these relations is a congruence in the usual sense. We also give an alternative characterisation of ~hp in terms of nonconditional transitions, as substitution-closed bisimilarity (denoted ~sb). Finally, we study the issue of recursion congruence: we prove that each of the above relations is a congruence with respect to the recursion operator; however, for ~ci this result holds under more restrictive conditions than for ~fh and ~hp.

An Until hierarchy and other applications of an Ehrenfeucht-Fraïssé game for temporal logic

Abstract: We prove there is a strict hierarchy of expressive power according to the Until depth of linear temporal logic (LTL) formulas: for each k, there is a natural property, based on quantitative fairness, that is not expressible with k nestings of Until operators, regardless of the number of applications of other operators, but is expressible by a formula with Until depth k+1. Our proof uses a new Ehrenfeucht?Fra??sse (EF) game designed specifically for LTL. These properties can all be expressed in first-order logic with quantifier depth and size O(logk), and we use them to observe some interesting relationships between LTL and first-order expressibility. We note that our Until hierarchy proof for LTL carries over to the branching time logics, CTL and CTL*. We then use the EF game in a novel way to effectively characterize (1) the LTL properties expressible without Until, as well as (2) those expressible without both Until and Next. By playing the game “on finite automata,” we prove that the automata recognizing languages expressible in each of the two fragments have distinctive structural properties. The characterization for the first fragment was originally proved by Cohen, Perrin, and Pin using sophisticated semigroup-theoretic techniques. They asked whether such a characterization exists for the second fragment. The technique we develop is general and can potentially be applied in other contexts.

Sequentiality, monadic second-order logic and tree automata

Abstract: Given a term rewriting system R and a normalizable term t, a redex is needed if in any reduction sequence of t to a normal form, this redex will be contracted. Roughly, R is sequential if there is an optimal reduction strategy in which only needed redexes are contracted. More generally, G. Huet and J.-J. Levy have defined the sequentiality of a predicate P on partially evaluated terms (1991, “Computational Logic: Essays in Honor of Alan Robinson”, MIT Press, Cambridge, MA, pp. 415–443). We show here that the sequentiality of P is definable in SkS, the monadic second-order logic with k successors, provided P is definable in SkS. We derive several known and new consequences of this remark: (1) strong sequentiality, as defined by Huet and Levy of a left linear (possibly overlapping) rewrite system is decidable, (2) NV-sequentiality, as defined in (M. Oyamaguchi, 1993, SIAM J. Comput.19, 424–437), is decidable, even in the case of overlapping rewrite systems (3) sequentiality of any linear shallow rewrite system is decidable. Then we describe a direct construction of a tree automaton recognizing the set of terms that do have needed redexes, which again, yields immediate consequences: (1) Strong sequentiality of possibly overlapping linear rewrite systems is decidable in EXPTIME, (2) For strongly sequential rewrite systems, needed redexes can be read directly on the automaton.

Tile formats for located and mobile systems

Abstract: Standard SOS formats are limited in their ability to define the operational semantics of process calculi with concurrency, causality, and mobility, and with bound names and name generation mechanisms. In this paper we describe a general approach, based on the tile model, to the definition of the operational semantics of process calculi. By providing tile systems for located CCS and asynchronous π -calculus we demonstrate that the proposed approach is more suited than SOS to provide a uniform treatment of concurrency and mobility within a compositional framework.

Decidability of bisimilarity for one-counter processes

Abstract: It is shown that bisimulation equivalence is decidable for the processes generated by (nondeterministic) pushdown automata, where the pushdown behaves like a counter. Also finiteness up to bisimilarity is shown to be decidable for the mentioned processes.

A randomized algorithm for two servers on the line

Abstract: In the k-server problem we wish to minimize, in an online fashion, the movement cost of k servers in response to a sequence of requests For two servers, it is known that the optimal deterministic algorithm has competitive ratio 2, and it has been a long-standing open problem whether it is possible to improve this ratio using randomization We give a positive answer to this problem when the underlying metric space is a real line, by providing a randomized online algorithm for this case with competitive ratio at most 155 78 ≈1987 This is the first algorithm for two servers that achieves a competitive ratio smaller than 2 in a nonuniform metric space with more than three points We consider a more general problem called the (k, l)-server problem, in which a request is served using l out of k available servers We show that the randomized 2-server problem can be reduced to the deterministic (2l, l)-server problem We prove a lower bound of 2 on the competitive ratio of the (4, 2)-server problem This implies that one unbiased random bit is not sufficient to improve the ratio of 2 for the two-server problem Then we give a 155 78 -competitive algorithm for the (6, 3)-server problem on the real line Our algorithm is simple and memoryless The solution has been obtained using linear programming techniques that may have applications for other online problems

Contracts, games, and refinement

Abstract: We consider the notion of a contract that governs the behavior of a collection of agents. In particular, we study the question of whether a group among these agents can achieve a given goal by following the contract. We show that this can be reduced to studying the existence of winning strategies in a two-person game. A notion of correctness and refinement is introduced for contracts and contracts are shown to form a lattice and a monoid with respect to the refinement ordering. We define a weakest precondition semantics for contracts that permits us to compute the initial states from which a group of agents has a winning strategy to reach their goal. This semantics generalizes the traditional predicate transformer semantics for program statements to contracts and games. Ordinary programs and interactive programs are special kinds of contracts.