pinecone/core-2020-05-10-deduplication huggingface dataset:
Parallel Preprocessing for Path Queries without Concurrent Reading

AbstractWe consider the problem of preprocessing a tree T with edge labels drawn from a semigroup such that subsequent queries for the semigroup product of the edge labels on a path in T can be answered efficiently. A sequential algorithm exhibiting an optimal trade-off between preprocessing time and query time was described by Chazelle. A parallelization of the preprocessing part of Chazelle's algorithm for the exclusive-read exclusive-write parallel RAM (EREW PRAM) was announced by Alon and Schieber, but few details were provided. Later a different solution, complete with all details, was described by Thorup, but it requires the stronger concurrent-read exclusive-write PRAM. We describe a simple algorithm for the EREW PRAM
Expressive Completeness of Duration Calculus

AbstractThis paper compares the expressive power of first-order monadic logic of order, a fundamental formalism in mathematical logic and the theory of computation, with that of the propositional version of duration calculus (PDC), a formalism for the specification of real-time systems. Our results show that the propositional duration calculus is expressively complete for first-order monadic logic of order. Our semantics for PDC conservatively extends the standard semantics to all positive (including infinite) length intervals. Hence, in view of the expressive completeness, liveness properties can be specified in PDC. This observation refutes a widely believed misconception that the duration calculus cannot specify liveness properties
Specification in CTL+Past for Verification in CTL

AbstractWe 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

AbstractTraditionally, 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⊂∼hp⊂∼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
Zero-Safe Nets: Comparing the Collective and Individual Token Approaches

AbstractThe 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
Contracts, Games, and Refinement

AbstractWe 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
Absolute versus Relative Time in Process Algebras

AbstractTimed process algebras are useful tools for the specification and verification of real-time systems. We study the relationships between two of these algebras, cIpa (closed interval process Algebra) and TCCS (temporal CCS), which deal with temporal aspects of concurrent systems by following very different interpretations: durational actions versus durationless actions, absolute time versus relative time, timed functional behavior versus time and functional behavior, local clocks versus global clocks. We show that these different choices are not irreconcilable by presenting simple mappings from cIpa to TCCS which preserve the behavioral equivalences over the two timed calculi. These results hold whenever basic actions are interpreted as either eager or lazy, whenever the starting time of action execution is observed rather than their completion time. A study on the size of the labelled transition systems describing the transitional semantics of cIpa processes and those describing the transitional semantics of their translated versions is also presented
What is a “Good” Encoding of Guarded Choice?

AbstractThe π-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
On the Expressiveness of Linda Coordination Primitives

AbstractWe 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
Bisimilarity in Term Graph Rewriting

AbstractWe present a survey of confluence properties of (acyclic) term graph rewriting. Results and counterexamples are given for different kinds of term graph rewriting; besides plain applications of rewrite rules, extensions with the operations of collapsing and copying, and both operations together are considered. Collapsing and copying together constitute bisimilarity of term graphs. We establish sufficient conditions for—and counterexamples to—confluence, confluence modulo bisimilarity, and the Church–Rosser property modulo bisimilarity. Moreover, we address rewriting modulo bisimilarity, that is, rewriting of bisimilarity classes of term graphs
Tile Formats for Located and Mobile Systems

AbstractStandard 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
Process Rewrite Systems

AbstractMany 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
Toward an Infinitary Logic of Domains: Abramsky Logic for Transition Systems

AbstractWe give a new characterization of sober spaces in terms of their completely distributive lattice of saturated sets. This characterization is used to extend Abramsky's results about a domain logic for transition systems. The Lindenbaum algebra generated by the Abramsky finitary logic is a distributive lattice dual to an SFP-domain obtained as a solution of a recursive domain equation. We prove that the Lindenbaum algebra generated by the infinitary logic is a completely distributive lattice dual to the same SFP-domain. As a consequence soundness and completeness of the infinitary logic is obtained for a class of transition systems that is computational interesting
Relational Interpretations of Recursive Types in an Operational Setting

AbstractRelational interpretations of type systems are useful for establishing properties of programming languages. For languages with recursive types it is difficult to establish the existence of a relational interpretation. The usual approach is to pass to a domain-theoretic model of the language and, exploiting the structure of the model, to derive relational properties of it. We investigate the construction of relational interpretations of recursive types in a purely operational setting, drawing on recent ideas from domain theory and operational semantics as a guide. We prove syntactic minimal invariance for an extension of PCF with a recursive type, a syntactic analogue of the minimal invariance property used by Freyd and Pitts to characterize the domain interpretation of a recursive type. As Pitts has shown in the setting of domains, syntactic minimal invariance suffices to establish the existence of relational interpretations. We give two applications of this construction. First, we derive a notion of logical equivalence for expressions of the language that we show coincides with experimental equivalence and which, by virtue of its construction, validates useful induction and coinduction principles for reasoning about the recursive type. Second, we give a relational proof of correctness of the continuation-passing transformation, which is used in some compilers for functional languages
Comparing Object Encodings

AbstractRecent years have seen the development of several foundational models for statically typed object-oriented programming. But despite their intuitive similarity, differences in the technical machinery used to formulate the various proposals have made them difficult to compare. Using the typed lambda-calculus Fω<: as a common basis, we now offer a detailed comparison of four models: (1) a recursive-record encoding similar to the ones used by Cardelli, Reddy, Cook, and others; (2) Hofmann, Pierce, and Turner's existential encoding; (3) Bruce's model based on existential and recursive types; and (4) Abadi, Cardelli, and Viswanathan's type-theoretic encoding of a calculus of primitive objects
Semi-Explicit First-Class Polymorphism for ML

AbstractWe propose a modest conservative extension to ML that allows semi-explicit first-class polymorphism while preserving the essential properties of type inference. In our proposal, the introduction of polymorphic types is fully explicit, that is, both introduction points and exact polymorphic types are to be specified. However, the elimination of polymorphic types is semi-implicit: only elimination points are to be specified as polymorphic types themselves are inferred. This extension is particularly useful in objective ML where polymorphism replaces subtyping
Type-Directed Specialization of Polymorphism

AbstractFlexibility of programming and efficiency of program execution are two important features of a programming language. Unfortunately, however, these two features conflict with each other in design and implementation of a modern statically typed programming language. Flexibility is achieved by a high-degree of polymorphism, which is based on generic primitives in an abstract model of computation, while efficiency requires optimal use of low-level primitives specialized to individual data structures. The motivation of this work is to reconcile these two features by developing a mechanism for specializing polymorphic primitives based on static type information. We analyze the existing methods for compiling a record calculus and an unboxed calculus, extract their common structure, and develop a framework for type-directed specialization of polymorphism
Higher Order Unification via Explicit Substitutions

AbstractHigher 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
Sequentiality, Monadic Second-Order Logic and Tree Automata

AbstractGiven 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. Lévy 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 Lévy 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
Counting Modulo Quantifiers on Finite Structures

AbstractWe give a combinatorial method for proving elementary equivalence in first-order logic FO with counting modulo n quantifiers Dn. Inexpressibility results for FO(Dn) with built-in linear order are also considered. For instance, the class of linear orders of length divisible by n+1 cannot be expressed in FO(Dn). Using this result we prove that comparing cardinalities or connectivity of ordered graphs are not definable in FO(Dn). We also show that the height of complete n-ary trees cannot be expressed in FO(Dn) with linear order. Interpreting the predicate y=nx as a complete n-ary tree, we show that the predicate y=px cannot be defined in FO(Dn) with linear order, whenever p has a prime factor that does not divide n. This solves the problem raised by Niwiński and Stolboushkin (LICS '93). We also discuss a connection between our results and the well-known open problem in circuit complexity theory, whether ACC=NC1
Algorithmic Analysis of Programs with Well Quasi-ordered Domains

AbstractOver 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
Integration in Real PCF

AbstractReal PCF is an extension of the programming language PCF with a data type for real numbers. Although a Real PCF definable real number cannot be computed in finitely many steps, it is possible to compute an arbitrarily small rational interval containing the real number in a sufficiently large number of steps. Based on a domain-theoretic approach to integration, we propose two approaches to integration in Real PCF. One consists in adding integration as primitive. The other consists in adding a primitive for function maximization and then recursively defining integration from maximization. In both cases we have a computational adequacy theorem for the corresponding extension of Real PCF. Moreover, based on previous work on Real PCF definability, we show that Real PCF extended with the maximization operator is universal
An Until Hierarchy and Other Applications of an Ehrenfeucht–Fraı̈ssé Game for Temporal Logic

AbstractWe 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ı̈ssé (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