7 research outputs found
First Order Linear Logic without Modalities Is NEXPTIME-Hard
The decision problem is studied for the nonmodal or multiplicative-additive fragment of first order linear logic. This fragment is shown to be nexptime- hard. The hardness proof combines Shapiro's logic programming simulation of nondeterministic Turing machines with the standard proof of the pspace- hardness of quantified boolean formula validity, utilizing some of the surprisingly powerful and expressive machinery of linear logic. 1 Introduction Linear logic, introduced by Girard, is a resource-sensitive refinement of classical logic [10, 29]. Linear logic gains its expressive power by restricting the "structural" proof rules of contraction (copying) and weakening (erasing). The contraction rule makes it possible to reuse any stated assumption as often as desired. The weakening rule makes it possible to use dummy assumptions, i.e., it allows a deduction to be carried out without using all of the hypotheses. Because contraction and weakening together make it possible to use an assu..
Model Checking Linear Logic Specifications
The overall goal of this paper is to investigate the theoretical foundations
of algorithmic verification techniques for first order linear logic
specifications. The fragment of linear logic we consider in this paper is based
on the linear logic programming language called LO enriched with universally
quantified goal formulas. Although LO was originally introduced as a
theoretical foundation for extensions of logic programming languages, it can
also be viewed as a very general language to specify a wide range of
infinite-state concurrent systems.
Our approach is based on the relation between backward reachability and
provability highlighted in our previous work on propositional LO programs.
Following this line of research, we define here a general framework for the
bottom-up evaluation of first order linear logic specifications. The evaluation
procedure is based on an effective fixpoint operator working on a symbolic
representation of infinite collections of first order linear logic formulas.
The theory of well quasi-orderings can be used to provide sufficient conditions
for the termination of the evaluation of non trivial fragments of first order
linear logic.Comment: 53 pages, 12 figures "Under consideration for publication in Theory
and Practice of Logic Programming
Method for Statically Checking an Object-oriented Computer Program Module
A method for statically checking an object-oriented computer program module includes the step of identifying objects within a computer program module, at least one of the objects having a plurality of references thereto, possibly from multiple clients. A discipline of permissions is imposed on the objects identified within the computer program module. The permissions enable tracking, from among a discrete set of changeable states, a subset of states each object might be in. A determination is made regarding whether the imposed permissions are violated by a potential reference to any of the identified objects. The results of the determination are output to a user
De Morgan Dual Nominal Quantifiers Modelling Private Names in Non-Commutative Logic
This paper explores the proof theory necessary for recommending an expressive
but decidable first-order system, named MAV1, featuring a de Morgan dual pair
of nominal quantifiers. These nominal quantifiers called `new' and `wen' are
distinct from the self-dual Gabbay-Pitts and Miller-Tiu nominal quantifiers.
The novelty of these nominal quantifiers is they are polarised in the sense
that `new' distributes over positive operators while `wen' distributes over
negative operators. This greater control of bookkeeping enables private names
to be modelled in processes embedded as formulae in MAV1. The technical
challenge is to establish a cut elimination result, from which essential
properties including the transitivity of implication follow. Since the system
is defined using the calculus of structures, a generalisation of the sequent
calculus, novel techniques are employed. The proof relies on an intricately
designed multiset-based measure of the size of a proof, which is used to guide
a normalisation technique called splitting. The presence of equivariance, which
swaps successive quantifiers, induces complex inter-dependencies between
nominal quantifiers, additive conjunction and multiplicative operators in the
proof of splitting. Every rule is justified by an example demonstrating why the
rule is necessary for soundly embedding processes and ensuring that cut
elimination holds.Comment: Submitted for review 18/2/2016; accepted CONCUR 2016; extended
version submitted to journal 27/11/201
Relating state-based and process-based concurrency through linear logic (full-version)
AbstractThis paper has the purpose of reviewing some of the established relationships between logic and concurrency, and of exploring new ones.Concurrent and distributed systems are notoriously hard to get right. Therefore, following an approach that has proved highly beneficial for sequential programs, much effort has been invested in tracing the foundations of concurrency in logic. The starting points of such investigations have been various idealized languages of concurrent and distributed programming, in particular the well established state-transformation model inspired by Petri nets and multiset rewriting, and the prolific process-based models such as the π-calculus and other process algebras. In nearly all cases, the target of these investigations has been linear logic, a formal language that supports a view of formulas as consumable resources. In the first part of this paper, we review some of these interpretations of concurrent languages into linear logic and observe that, possibly modulo duality, they invariably target a small semantic fragment of linear logic that we call LVobs.In the second part of the paper, we propose a new approach to understanding concurrent and distributed programming as a manifestation of logic, which yields a language that merges those two main paradigms of concurrency. Specifically, we present a new semantics for multiset rewriting founded on an alternative view of linear logic and specifically LVobs. The resulting interpretation is extended with a majority of linear connectives into the language of ω-multisets. This interpretation drops the distinction between multiset elements and rewrite rules, and considerably enriches the expressive power of standard multiset rewriting with embedded rules, choice, replication, and more. Derivations are now primarily viewed as open objects, and are closed only to examine intermediate rewriting states. The resulting language can also be interpreted as a process algebra. For example, a simple translation maps process constructors of the asynchronous π-calculus to rewrite operators. The language of ω-multisets forms the basis for the security protocol specification language MSR 3. With relations to both multiset rewriting and process algebra, it supports specifications that are process-based, state-based, or of a mixed nature, with the potential of combining verification techniques from both worlds. Additionally, its logical underpinning makes it an ideal common ground for systematically comparing protocol specification languages