22 research outputs found
Towards Races in Linear Logic
Process calculi based in logic, such as DILL and CP, provide a
foundation for deadlock-free concurrent programming, but exclude
non-determinism and races. HCP is a reformulation of CP which addresses a
fundamental shortcoming: the fundamental operator for parallel composition from
the -calculus does not correspond to any rule of linear logic, and
therefore not to any term construct in CP.
We introduce non-deterministic HCP, which extends HCP with a novel account of
non-determinism. Our approach draws on bounded linear logic to provide a
strongly-typed account of standard process calculus expressions of
non-determinism. We show that our extension is expressive enough to capture
many uses of non-determinism in untyped calculi, such as non-deterministic
choice, while preserving HCP's meta-theoretic properties, including deadlock
freedom
Prioritise the Best Variation
Binary session types guarantee communication safety and session fidelity, but alone they cannot rule out deadlocks arising from the interleaving of different sessions. In Classical Processes (CP) [53]—a process calculus based on classical linear logic—deadlock freedom is guaranteed by combining channel creation and parallel composition under the same logical cut rule. Similarly, in Good Variation (GV) [39, 54]—a linear concurrent λ-calculus—deadlock freedom is guaranteed by combining channel creation and thread spawning under the same operation, called fork. In both CP and GV, deadlock freedom is achieved at the expense of expressivity, as the only processes allowed are tree-structured. Dardha and Gay [19] define Priority CP (PCP), which allows cyclic-structured processes and restores deadlock freedom by using priorities, in line with Kobayashi and Padovani [34, 44]. Following PCP, we present Priority GV (PGV), a variant of GV which decouples channel creation from thread spawning. Consequently, we type cyclic-structured processes and restore deadlock freedom by using priorities. We show that our type system is sound by proving subject reduction and progress. We define an encoding from PCP to PGV and prove that the encoding preserves typing and is sound and complete with respect to the operational semantics
Prioritise the Best Variation
Binary session types guarantee communication safety and session fidelity, but
alone they cannot rule out deadlocks arising from the interleaving of different
sessions. In Classical Processes (CP)a process calculus based on classical
linear logicdeadlock freedom is guaranteed by combining channel creation and
parallel composition under the same logical cut rule. Similarly, in Good
Variation (GV)a linear concurrent -calculusdeadlock freedom is
guaranteed by combining channel creation and thread spawning under the same
operation, called fork.
In both CP and GV, deadlock freedom is achieved at the expense of
expressivity, as the only processes allowed are tree-structured. Dardha and Gay
define Priority CP (PCP), which allows cyclic-structured processes and restores
deadlock freedom by using priorities, in line with Kobayashi and Padovani.
Following PCP, we present Priority GV (PGV), a variant of GV which decouples
channel creation from thread spawning. Consequently, we type cyclic-structured
processes and restore deadlock freedom by using priorities. We show that our
type system is sound by proving subject reduction and progress. We define an
encoding from PCP to PGV and prove that the encoding preserves typing and is
sound and complete with respect to the operational semantics
Deadlock-Free Session Types in Linear Haskell
Priority Sesh is a library for session-typed communication in Linear Haskell which offers strong compile-time correctness guarantees. Priority Sesh offers two deadlock-free APIs for session-typed communication. The first guarantees deadlock freedom by restricting the process structure to trees and forests. It is simple and composeable, but rules out cyclic structures. The second guarantees deadlock freedom via priorities, which allows the programmer to safely use cyclic structures as well. Our library relies on Linear Haskell to guarantee linearity, which leads to easy-to-write session types and more idiomatic code, and lets us avoid the complex encodings of linearity in the Haskell type system that made previous libraries difficult to use
Towards Races in Linear Logic
Process calculi based in logic, such as DILL and CP, provide a
foundation for deadlock-free concurrent programming, but exclude
non-determinism and races. HCP is a reformulation of CP which addresses a
fundamental shortcoming: the fundamental operator for parallel composition from
the -calculus does not correspond to any rule of linear logic, and
therefore not to any term construct in CP.
We introduce non-deterministic HCP, which extends HCP with a novel account of
non-determinism. Our approach draws on bounded linear logic to provide a
strongly-typed account of standard process calculus expressions of
non-determinism. We show that our extension is expressive enough to capture
many uses of non-determinism in untyped calculi, such as non-deterministic
choice, while preserving HCP's meta-theoretic properties, including deadlock
freedom
Property-driven Training: All You (N)Ever Wanted to Know About
Neural networks are known for their ability to detect general patterns in
noisy data. This makes them a popular tool for perception components in complex
AI systems. Paradoxically, they are also known for being vulnerable to
adversarial attacks. In response, various methods such as adversarial training,
data-augmentation and Lipschitz robustness training have been proposed as means
of improving their robustness. However, as this paper explores, these training
methods each optimise for a different definition of robustness. We perform an
in-depth comparison of these different definitions, including their
relationship, assumptions, interpretability and verifiability after training.
We also look at constraint-driven training, a general approach designed to
encode arbitrary constraints, and show that not all of these definitions are
directly encodable. Finally we perform experiments to compare the applicability
and efficacy of the training methods at ensuring the network obeys these
different definitions. These results highlight that even the encoding of such a
simple piece of knowledge such as robustness in neural network training is
fraught with difficult choices and pitfalls.Comment: 10 pages, under revie
Separating Sessions Smoothly
This paper introduces Hypersequent GV (HGV), a modular and extensible core
calculus for functional programming with session types that enjoys deadlock
freedom, confluence, and strong normalisation. HGV exploits hyper-environments,
which are collections of type environments, to ensure that structural
congruence is type preserving. As a consequence we obtain an operational
correspondence between HGV and HCP -- a process calculus based on hypersequents
and in a propositions-as-types correspondence with classical linear logic
(CLL). Our translations from HGV to HCP and vice-versa both preserve and
reflect reduction. HGV scales smoothly to support Girard's Mix rule, a crucial
ingredient for channel forwarding and exceptions