Journal of Logical and Algebraic Methods in Programming最新文献

In the context of intuitionistic sequent calculus, “naturality” means permutation-freeness (the terminology is essentially due to Mints). We study naturality in the context of the lambda-calculus with generalized applications and its multiary extension, to cover, under the Curry-Howard correspondence, proof systems ranging from natural deduction (with and without general elimination rules) to a fragment of sequent calculus with an iterable left-introduction rule, and which can still be recognized as a call-by-name lambda-calculus. In this context, naturality consists of a certain restricted use of generalized applications. We consider the further restriction obtained by the combination of naturality with normality w.r.t. the commutative conversion engendered by generalized applications. This combination sheds light on the interpretation of naturality as a vectorization mechanism, allowing a multitude of different ways of structuring lambda-terms, and the structuring of a multitude of interesting fragments of the systems under study. We also consider a relaxation of naturality, called weak naturality: this not only brings similar structural benefits, but also suggests a new “weak” system of natural deduction with generalized applications which is exempt from commutative conversions. In the end, we use all of this evidence as a stepping stone to propose a computational interpretation of generalized application (whether multiary or not, and without any restriction): it includes, alongside the argument(s) for the function, a general list – a new, very general, vectorization mechanism, that structures the continuation of the computation.

FIFO automata are finite state machines communicating through FIFO queues. They can be used, for instance, to model distributed protocols. Due to the unboundedness of the FIFO queues, several verification problems are undecidable for these systems. In order to model check such systems, one may look for decidable subclasses of FIFO systems. Binary half-duplex systems are systems of two FIFO automata exchanging over a half-duplex channel. They were studied by Cécé and Finkel who established the decidability in polynomial time of several properties. There is no obvious way to generalize the half-duplex property to multiparty systems. Cécé and Finkel proposed some generalizations but concluded that their notions of multiparty half-duplex systems were either too restrictive or too expressive.

We explore in this paper other ways of generalizing half-duplex systems to multiparty. First, we introduce systems realizable with synchronous communications (RSC) and we show that RSC systems generalize half-duplex systems and retain the same good properties as binary half-duplex systems. Second, we introduce a notion of multiparty half-duplex systems that differs from the ones explored by Cécé and Finkel, and we show two results about this notion: (1) for mailbox communications, half-duplex systems are essentially the same as RSC systems, and (2) for peer-to-peer communications, the two notions are distinct, and RSC systems appear to be “the good one”, since peer-to-peer half-duplex systems are Turing powerful.

Background

Efficient querying of large graph structures is a problem at the heart of several application domains such as social networks and model driven engineering. In particular in the context of model driven engineering, where the same query is executed frequently over an evolving graph structure, incremental techniques based on RETE nets are a popular solution. However, the construction of adequate RETE nets for a specific problem instance is a challenge in and of itself.

Methods

In this article, we propose an approach to RETE net construction for queries in the form of graph patterns equipped with nested graph conditions that considers not only the structure of the query, but also the structure of the host graph to improve the net's performance regarding execution time and memory consumption. Furthermore, we suggest a technique for adapting the net structure to changing host graph characteristics. We evaluate the presented concepts empirically based on queries and data from two independent benchmarks, using a mature tool for incremental graph pattern matching as a reference.

Results

Our evaluation results indicate that considering host graph structure during RETE net construction can improve performance of the resulting net. The experiments also demonstrate that adapting the net structure to changing host graph characteristics can be performed with an acceptable execution time overhead for our examples and may yield more adequate RETE nets. Overall, our approach never performed worse than the reference by more than factor 1.2 regarding execution time and achieved an improvement by up to factor 20.

Establishing equivalences between programs is crucial both for verifying correctness of programs and for justifying optimisations and program transformations. There exist several equivalence relations for programs, and bisimulations are among the most versatile of these equivalences. Among bisimulations one distinguishes strong bisimulation that requires that each action of a program is simulated by a single action of the equivalent program, and weak bisimulation that allows some of the actions to be invisible, and thus not simulated.

pNet is a generalisation of automata that model open systems. They feature variables and hierarchical composition. Open pNets are pNets with holes, i.e. placeholders that can be filled later by sub-systems. However, there is no standard tool for defining the semantics of an open system in this context. This article first defines open automata that are labelled transition systems with parameters and holes. Relying on open automata, it then defines bisimilarity relations for the comparison of systems specified as pNets. We first present a strong bisimilarity for open pNets called FH-bisimilarity. Next we offer an equivalence relation similar to the classical weak bisimulation equivalence, and study its properties. Among these properties we are interested in compositionality: if two systems are proven equivalent they will be indistinguishable by their context, and they will also be indistinguishable when their holes are filled with equivalent systems. We identify sufficient conditions to ensure compositionality of strong and weak bisimulation. The contributions of this article are illustrated using a transport protocol as running example.

We propose an interpretation of multiparty sessions as Flow Event Structures, which allows concurrency within sessions to be explicitly represented. We show that this interpretation is equivalent, when the multiparty sessions can be described by global types, to an interpretation of such global types as Prime Event Structures.

Dependent type theories with guarded recursion have shown themselves suitable for the development of denotational semantics of programming languages. In particular, Ticked Cubical Type Theory (TCTT) has been used to show that, for guarded labeled transition systems (GLTS), interpretation into the denotational semantics maps bisimilar processes to equal values. In fact the two notions are proved equivalent, allowing one to reason about equality in place of bisimilarity.

We extend that result to the Calculus of Communicating Systems (CCS) and the π-calculus. For the latter, we pick early congruence as the syntactic notion of equivalence between processes, showing that denotational models based on guarded recursive types can handle the dynamic creation of channels that goes beyond the scope of GLTSs.

Hence we present fully abstract denotational models for CCS and the early π-calculus, formalized as an extended example for Guarded Cubical Agda: a novel implementation of Ticked Cubical Type Theory based on Cubical Agda.

Drags are a recent, natural generalization of terms which admit arbitrary cycles. A key aspect of drags is that they can be equipped with a composition operator so that rewriting amounts to replace a drag by another in a composition. In this paper, we develop a unification algorithm for drags that allows to check the local confluence property of a set of drag rewrite rules.

This paper develops an algorithmic-based approach for proving inductive properties of propositional sequent systems such as admissibility, invertibility, cut-admissibility, and identity expansion. Although undecidable in general, these structural properties are crucial in proof theory because they can reduce the proof-search effort and further be used as scaffolding for obtaining other meta-results such as consistency. The algorithms –which take advantage of the rewriting logic meta-logical framework– are explained in detail and illustrated with examples throughout the paper. They have been fully mechanized in the L-Framework, thus offering both a formal specification language and off-the-shelf mechanization of the proof-search algorithms coming together with semi-decision procedures for proving theorems and meta-theorems of the object system. As illustrated with case studies in the paper, the L-Framework achieves a great degree of automation when used on several propositional sequent systems, including single conclusion and multi-conclusion intuitionistic logic, classical logic, classical linear logic and its dyadic system, intuitionistic linear logic, and normal modal logics.

Program logics typically reason about an over-approximation of program behaviour to prove the absence of bugs. Recently, program logics have been proposed that instead prove the presence of bugs by means of under-approximate reasoning, which has the promise of better scalability. In this paper, we present an under-approximate program logic for GP 2, a rule-based programming language for manipulating graphs. We define the proof rules of this program logic extensionally, i.e. independently of fixed assertion languages, then instantiate them with a morphism-based assertion language able to specify monadic second-order properties on graphs (e.g. path properties). We show how these proof rules can be used to reason deductively about the presence of forbidden graph structure or failing executions. Finally, we prove our ‘incorrectness logic’ to be sound, and our extensional proof rules to be relatively complete.

In this article, a novel form of white-box testing is used to test an implementation of the Noise Cryptographic Protocol Framework, which is used as an integral component in a commercial blockchain. Our approach extends the normal interoperability testing, where the noise implementation under test, written in the Erlang programming language, is tested against an implementation of the Noise protocol framework written in the C programming language. Testing typically performs a noise protocol handshake between the two implementations. If successful, then both implementations are considered compatible. However, such testing does not, for example, detect whether the Erlang implementation incorrectly reuse session keys that should have been newly generated. In this article, such interoperability testing is extended to also check that keys and information transmitted in protocol handshakes is correctly constructed, e.g., that session keys are freshly generated by calling the correct low-level cryptographic libraries. Such extended, white-box testing, begins by tracing the Erlang Noise implementation during protocol handshakes with the C programming protocol implementation. The resulting protocol trace is refactored, obtaining as the end result a symbolic description (a functional term) of how key protocol values are constructed using cryptographic operations and keys. Thereafter, this symbolic term is compared, using term rewriting, with another symbolic term representing the ideal symbolic execution of the tested Noise protocol handshake, i.e., the “semantics” of the handshake. The semantic symbolic term is obtained by executing a symbolic implementation of the noise protocol that we have developed, which very closely follows the semi-formal authoritative description of the Noise protocol framework.