1,478 research outputs found
On the Expressiveness of Intensional Communication
The expressiveness of communication primitives has been explored in a common
framework based on the pi-calculus by considering four features: synchronism
(asynchronous vs synchronous), arity (monadic vs polyadic data), communication
medium (shared dataspaces vs channel-based), and pattern-matching (binding to a
name vs testing name equality). Here pattern-matching is generalised to account
for terms with internal structure such as in recent calculi like Spi calculi,
Concurrent Pattern Calculus and Psi calculi. This paper explores intensionality
upon terms, in particular communication primitives that can match upon both
names and structures. By means of possibility/impossibility of encodings, this
paper shows that intensionality alone can encode synchronism, arity,
communication-medium, and pattern-matching, yet no combination of these without
intensionality can encode any intensional language.Comment: In Proceedings EXPRESS/SOS 2014, arXiv:1408.127
Psi-calculi: a framework for mobile processes with nominal data and logic
The framework of psi-calculi extends the pi-calculus with nominal datatypes
for data structures and for logical assertions and conditions. These can be
transmitted between processes and their names can be statically scoped as in
the standard pi-calculus. Psi-calculi can capture the same phenomena as other
proposed extensions of the pi-calculus such as the applied pi-calculus, the
spi-calculus, the fusion calculus, the concurrent constraint pi-calculus, and
calculi with polyadic communication channels or pattern matching. Psi-calculi
can be even more general, for example by allowing structured channels,
higher-order formalisms such as the lambda calculus for data structures, and
predicate logic for assertions. We provide ample comparisons to related calculi
and discuss a few significant applications. Our labelled operational semantics
and definition of bisimulation is straightforward, without a structural
congruence. We establish minimal requirements on the nominal data and logic in
order to prove general algebraic properties of psi-calculi, all of which have
been checked in the interactive theorem prover Isabelle. Expressiveness of
psi-calculi significantly exceeds that of other formalisms, while the purity of
the semantics is on par with the original pi-calculus.Comment: 44 page
A Fully Abstract Symbolic Semantics for Psi-Calculi
We present a symbolic transition system and bisimulation equivalence for
psi-calculi, and show that it is fully abstract with respect to bisimulation
congruence in the non-symbolic semantics.
A psi-calculus is an extension of the pi-calculus with nominal data types for
data structures and for logical assertions representing facts about data. These
can be transmitted between processes and their names can be statically scoped
using the standard pi-calculus mechanism to allow for scope migrations.
Psi-calculi can be more general than other proposed extensions of the
pi-calculus such as the applied pi-calculus, the spi-calculus, the fusion
calculus, or the concurrent constraint pi-calculus.
Symbolic semantics are necessary for an efficient implementation of the
calculus in automated tools exploring state spaces, and the full abstraction
property means the semantics of a process does not change from the original
On the Expressiveness of Joining
The expressiveness of communication primitives has been explored in a common
framework based on the pi-calculus by considering four features: synchronism
(asynchronous vs synchronous), arity (monadic vs polyadic data), communication
medium (shared dataspaces vs channel-based), and pattern-matching (binding to a
name vs testing name equality vs intensionality). Here another dimension
coordination is considered that accounts for the number of processes required
for an interaction to occur. Coordination generalises binary languages such as
pi-calculus to joining languages that combine inputs such as the Join Calculus
and general rendezvous calculus. By means of possibility/impossibility of
encodings, this paper shows coordination is unrelated to the other features.
That is, joining languages are more expressive than binary languages, and no
combination of the other features can encode a joining language into a binary
language. Further, joining is not able to encode any of the other features
unless they could be encoded otherwise.Comment: In Proceedings ICE 2015, arXiv:1508.04595. arXiv admin note:
substantial text overlap with arXiv:1408.145
An Intensional Concurrent Faithful Encoding of Turing Machines
The benchmark for computation is typically given as Turing computability; the
ability for a computation to be performed by a Turing Machine. Many languages
exploit (indirect) encodings of Turing Machines to demonstrate their ability to
support arbitrary computation. However, these encodings are usually by
simulating the entire Turing Machine within the language, or by encoding a
language that does an encoding or simulation itself. This second category is
typical for process calculi that show an encoding of lambda-calculus (often
with restrictions) that in turn simulates a Turing Machine. Such approaches
lead to indirect encodings of Turing Machines that are complex, unclear, and
only weakly equivalent after computation. This paper presents an approach to
encoding Turing Machines into intensional process calculi that is faithful,
reduction preserving, and structurally equivalent. The encoding is demonstrated
in a simple asymmetric concurrent pattern calculus before generalised to
simplify infinite terms, and to show encodings into Concurrent Pattern Calculus
and Psi Calculi.Comment: In Proceedings ICE 2014, arXiv:1410.701
Formal Verification of Security Protocol Implementations: A Survey
Automated formal verification of security protocols has been mostly focused on analyzing high-level abstract models which, however, are significantly different from real protocol implementations written in programming languages. Recently, some researchers have started investigating techniques that bring automated formal proofs closer to real implementations. This paper surveys these attempts, focusing on approaches that target the application code that implements protocol logic, rather than the libraries that implement cryptography. According to these approaches, libraries are assumed to correctly implement some models. The aim is to derive formal proofs that, under this assumption, give assurance about the application code that implements the protocol logic. The two main approaches of model extraction and code generation are presented, along with the main techniques adopted for each approac
Proving More Observational Equivalences with ProVerif
This paper presents an extension of the automatic protocol verifier ProVerif in order to prove more observational equivalences. ProVerif can prove observational equivalence between processes that have the same structure but differ by the messages they contain. In order to extend the class of equivalences that ProVerif handles, we extend the language of terms by defining more functions (destructors) by rewrite rules. In particular, we allow rewrite rules with inequalities as side-conditions, so that we can express tests ''if then else'' inside terms. Finally, we provide an automatic procedure that translates a process into an equivalent process that performs as many actions as possible in- side terms, to allow ProVerif to prove the desired equivalence. These extensions have been implemented in ProVerif and allow us to au- tomatically prove anonymity in the private authentication protocol by Abadi and Fournet
On correctness of buffer implementations in a concurrent lambda calculus with futures
Motivated by the question of correctness of a specific implementation of concurrent buffers in the lambda calculus with futures underlying Alice ML, we prove that concurrent buffers and handled futures can correctly encode each other. Correctness means that our encodings preserve and reflect the observations of may- and must-convergence. This also shows correctness wrt. program semantics, since the encodings are adequate translations wrt. contextual semantics. While these translations encode blocking into queuing and waiting, we also provide an adequate encoding of buffers in a calculus without handles, which is more low-level and uses busy-waiting instead of blocking. Furthermore we demonstrate that our correctness concept applies to the whole compilation process from high-level to low-level concurrent languages, by translating the calculus with buffers, handled futures and data constructors into a small core language without those constructs
Formally based semi-automatic implementation of an open security protocol
International audienceThis paper presents an experiment in which an implementation of the client side of the SSH Transport Layer Protocol (SSH-TLP) was semi-automatically derived according to a model-driven development paradigm that leverages formal methods in order to obtain high correctness assurance. The approach used in the experiment starts with the formalization of the protocol at an abstract level. This model is then formally proved to fulfill the desired secrecy and authentication properties by using the ProVerif prover. Finally, a sound Java implementation is semi-automatically derived from the verified model using an enhanced version of the Spi2Java framework. The resulting implementation correctly interoperates with third party servers, and its execution time is comparable with that of other manually developed Java SSH-TLP client implementations. This case study demonstrates that the adopted model-driven approach is viable even for a real security protocol, despite the complexity of the models needed in order to achieve an interoperable implementation
- …