194 research outputs found
Fair Termination of Binary Sessions
A binary session is a private communication channel that connects two processes, each adhering to a protocol description called session type. In this work, we study the first type system that ensures the fair termination of binary sessions. A session fairly terminates if all of the infinite executions admitted by its protocol are deemed ‘unrealistic’ because they violate certain fairness assumptions. Fair termination entails the eventual completion of all pending input/output actions, including those that depend on the completion of an unbounded number of other actions in possibly different sessions. This form of lock freedom allows us to address a large family of natural communication patterns that fall outside the scope of existing type systems. Our type system is also the first to adopt fair subtyping, a liveness-preserving refinement of the standard subtyping relation for session types that so far has only been studied theoretically. Fair subtyping is surprisingly subtle not only to characterize concisely but also to use appropriately, to the point that the type system must carefully account for all usages of fair subtyping to avoid compromising its liveness-preserving properties
Inference Systems with Corules for Fair Subtyping and Liveness Properties of Binary Session Types
Many properties of communication protocols stem from the combination of safety and liveness properties. Characterizing such combined properties by means of a single inference system is difficult because of the fundamentally different techniques (coinduction and induction, respectively) usually involved in defining and proving them. In this paper we show that Generalized Inference Systems allow for simple and insightful characterizations of (at least some of) these combined inductive/coinductive properties for dependent session types. In particular, we illustrate the role of corules in characterizing weak termination (the property of protocols that can always eventually terminate), fair compliance (the property of interactions that can always be extended to reach client satisfaction) and also fair subtyping, a liveness-preserving refinement relation for session types
An Infinitary Proof Theory of Linear Logic Ensuring Fair Termination in the Linear ?-Calculus
Fair termination is the property of programs that may diverge "in principle" but that terminate "in practice", i.e. under suitable fairness assumptions concerning the resolution of non-deterministic choices. We study a conservative extension of ?MALL^?, the infinitary proof system of the multiplicative additive fragment of linear logic with least and greatest fixed points, such that cut elimination corresponds to fair termination. Proof terms are processes of ?LIN, a variant of the linear ?-calculus with (co)recursive types into which binary and (some) multiparty sessions can be encoded. As a result we obtain a behavioral type system for ?LIN (and indirectly for session calculi through their encoding into ?LIN) that ensures fair termination: although well-typed processes may engage in arbitrarily long interactions, they are fairly guaranteed to eventually perform all pending actions
Ain't No Stopping Us Monitoring Now
Not all properties are monitorable. This is a well-known fact, and it means
there exist properties that cannot be fully verified at runtime. However, given
a non-monitorable property, a monitor can still be synthesised, but it could
end up in a state where no verdict will ever be concluded on the satisfaction
(resp., violation) of the property. For this reason, non-monitorable properties
are usually discarded. In this paper, we carry out an in-depth analysis on
monitorability, and how non-monitorable properties can still be partially
verified. We present our theoretical results at a semantic level, without
focusing on a specific formalism. Then, we show how our theory can be applied
to achieve partial runtime verification of Linear Temporal Logic (LTL)
Flexible Coinduction in Agda
We provide an Agda library for inference systems, also supporting their recent generalization allowing flexible coinduction, that is, interpretations which are neither inductive, nor purely coinductive. A specific inference system can be obtained as an instance by writing a set of meta-rules, in an Agda format which closely resembles the usual one. In this way, the user gets for free the related properties, notably the inductive and coinductive intepretation and the corresponding proof principles. Moreover, a significant modularity is achieved. Indeed, rather than being defined from scratch and with a built-in interpretation, an inference system can also be obtained by composition operators, such as union and restriction to a smaller universe, and its semantics can be modularly chosen as well. In particular, flexible coinduction is obtained by composing in a certain way the interpretations of two inference systems. We illustrate the use of the library by several examples. The most significant one is a big-step semantics for the ?-calculus, where flexible coinduction allows to obtain a special result (?) for all and only the diverging computations, and the proof of equivalence with small-step semantics is carried out by relying on the proof principles offered by the library
Flexible Coinduction in Agda
Theorem provers are tools that help users to write machine readable proofs.
Some of this tools are also interactive. The need of such softwares is
increasing since they provide proofs that are more certified than the hand
written ones. Agda is based on type theory and on the propositions-as-types
correspondence and has a Haskell-like syntax. This means that a proof of a
statement is turned into a function. Inference systems are a way of defining
inductive and coinductive predicates and induction and coinduction principles
are provided to help proving their correctness with respect to a given
specification in terms of soundness and completeness. Generalized inference
systems deal with predicates whose inductive and coinductive interpretations do
not provide the expected set of judgments. In this case inference systems are
enriched by corules that are rules that can be applied at infinite depth in a
proof tree. Induction and coinduction principles cannot be used in case of
generalized inference systems and the bounded coinduction one has been
proposed. We first present how Agda supports inductive and coinductive types
highlighting the fact that data structures and predicates are defined using the
same constructs. Then we move to the main topic of this thesis, which is
investigating how generalized inference systems can be implemented and how
their correctness can be proved
Inference Systems with Corules for Combined Safety and Liveness Properties of Binary Session Types
Many properties of communication protocols combine safety and liveness
aspects. Characterizing such combined properties by means of a single inference
system is difficult because of the fundamentally different techniques
(coinduction and induction, respectively) usually involved in defining and
proving them. In this paper we show that Generalized Inference Systems allow us
to obtain sound and complete characterizations of (at least some of) these
combined inductive/coinductive properties of binary session types. In
particular, we illustrate the role of corules in characterizing fair
termination (the property of protocols that can always eventually terminate),
fair compliance (the property of interactions that can always be extended to
reach client satisfaction) and fair subtyping, a liveness-preserving refinement
relation for session types. The characterizations we obtain are simpler
compared to the previously available ones and corules provide insight on the
liveness properties being ensured or preserved. Moreover, we can conveniently
appeal to the bounded coinduction principle to prove the completeness of the
provided characterizations
A marriage between adversarial team games and 2-player games: enabling abstractions, no-regret learning, and subgame solving
Ex ante correlation is becoming the mainstream approach for sequential adversarial team games,where a team of players faces another team in a
zero-sum game. It is known that team members’asymmetric information makes both equilibrium computation APX-hard and team’s strategies not
directly representable on the game tree. This latter issue prevents the adoption of successful tools for huge 2-player zero-sum games such as,
e.g., abstractions, no-regret learning, and sub game solving. This work shows that we can re cover from this weakness by bridging the gap be tween sequential adversarial team games and 2-player games. In particular, we propose a new,suitable game representation that we call team public-information, in which a team is repre sented as a single coordinator who only knows information common to the whole team and pre scribes to each member an action for any pos sible private state. The resulting representation is highly explainable, being a 2-player tree in
which the team’s strategies are behavioral with a direct interpretation and more expressive than he original extensive form when designing ab stractions. Furthermore, we prove payoff equiva lence of our representation, and we provide tech niques that, starting directly from the extensive form, generate dramatically more compact repre sentations without information loss. Finally, we experimentally evaluate our techniques when ap plied to a standard testbed, comparing their per formance with the current state of the art
Public Information Representation for Adversarial Team Games
The peculiarity of adversarial team games resides in the asymmetric
information available to the team members during the play, which makes the
equilibrium computation problem hard even with zero-sum payoffs. The algorithms
available in the literature work with implicit representations of the strategy
space and mainly resort to Linear Programming and column generation techniques
to enlarge incrementally the strategy space. Such representations prevent the
adoption of standard tools such as abstraction generation, game solving, and
subgame solving, which demonstrated to be crucial when solving huge, real-world
two-player zero-sum games. Differently from these works, we answer the question
of whether there is any suitable game representation enabling the adoption of
those tools. In particular, our algorithms convert a sequential team game with
adversaries to a classical two-player zero-sum game. In this converted game,
the team is transformed into a single coordinator player who only knows
information common to the whole team and prescribes to the players an action
for any possible private state. Interestingly, we show that our game is more
expressive than the original extensive-form game as any state/action
abstraction of the extensive-form game can be captured by our representation,
while the reverse does not hold. Due to the NP-hard nature of the problem, the
resulting Public Team game may be exponentially larger than the original one.
To limit this explosion, we provide three algorithms, each returning an
information-lossless abstraction that dramatically reduces the size of the
tree. These abstractions can be produced without generating the original game
tree. Finally, we show the effectiveness of the proposed approach by presenting
experimental results on Kuhn and Leduc Poker games, obtained by applying
state-of-art algorithms for two-player zero-sum games on the converted gamesComment: 19 pages, 7 figures, Best Paper Award in Cooperative AI Workshop at
NeurIPS 202
From Charts to Atlas: Merging Latent Spaces into One
Models trained on semantically related datasets and tasks exhibit comparable
inter-sample relations within their latent spaces. We investigate in this study
the aggregation of such latent spaces to create a unified space encompassing
the combined information. To this end, we introduce Relative Latent Space
Aggregation, a two-step approach that first renders the spaces comparable using
relative representations, and then aggregates them via a simple mean. We
carefully divide a classification problem into a series of learning tasks under
three different settings: sharing samples, classes, or neither. We then train a
model on each task and aggregate the resulting latent spaces. We compare the
aggregated space with that derived from an end-to-end model trained over all
tasks and show that the two spaces are similar. We then observe that the
aggregated space is better suited for classification, and empirically
demonstrate that it is due to the unique imprints left by task-specific
embedders within the representations. We finally test our framework in
scenarios where no shared region exists and show that it can still be used to
merge the spaces, albeit with diminished benefits over naive merging.Comment: To appear in the NeurReps workshop @ NeurIPS 202
- …