16 research outputs found
Quantitative program reasoning with graded modal types
In programming, data is often considered to be infinitely copiable, arbitrarily discardable, and universally unconstrained. However this view is naive: some data encapsulates resources that are subject to protocols (e.g., file and device handles, channels); some data should not be arbitrarily copied or communicated (e.g., private data). Linear types provide a partial remedy by delineating data in two camps: "resources" to be used but never copied or discarded, and unconstrained values. However, this binary distinction is too coarse-grained. Instead, we propose the general notion of graded modal types, which in combination with linear and indexed types, provides an expressive type theory for enforcing fine-grained resource-like properties of data. We present a type system drawing together these aspects (linear, graded, and indexed) embodied in a fully-fledged functional language implementation, called Granule. We detail the type system, including its metatheoretic properties, and explore examples in the concrete language. This work advances the wider goal of expanding the reach of type systems to capture and verify a broader set of program properties
Graded Modal Types for Integrity and Confidentiality
Graded type systems, such as the one underlying the Granule programming
language, allow various different properties of a program's behaviour to be
tracked via annotating types with additional information, which we call grades.
One example of such a property, often used as a case study in prior work on
graded types, is information flow control, in which types are graded by a
lattice of security levels allowing noninterference properties to be
automatically verified and enforced. These typically focus on one particular
aspect of security, however, known as confidentiality; public outputs are
prohibited from depending on private inputs. Integrity, a property specifying
that trusted outputs must not depend on untrusted inputs, has not been examined
in this context.
This short paper aims to remedy this omission. It is well-known that
confidentiality and integrity are in some sense dual properties, but simply
reversing the ordering of the security lattice turns out to be unsatisfactory
for the purpose of combining both kinds of property in a single system, at
least in our setting. We analogize the situation to recent work on embedding
both linear and uniqueness types in a graded framework, and use this framing to
demonstrate that we can enforce both integrity and confidentiality alongside
one another. The main idea is to add an additional flavour of modality
annotated for integrity, such that the existing graded comonad for tracking
confidentiality now also acts as a relative monad over the new modality, with
rules allowing information to flow from trusted to public to private.Comment: 3 pages. Originally presented as a short paper at PLAS 202
A Java-like Calculus with User-Defined Coeffects
We propose a Java-like calculus where declared variables can be annotated by coeffects specifying constraints on their use, such as linearity or privacy levels. Annotations are written in the language itself, as expressions of type Coeffect, a predefined class which can be extended by user-defined subclasses, modeling the coeffects desired for a specific application. We formalize the type system and prove subject reduction, which includes preservation of coeffects, and show several examples
Resource transition systems and full abstraction for linear higher-order effectful programs
We investigate program equivalence for linear higher-order (sequential) languages endowed with primitives for computational effects. More specifically, we study operationally-based notions of program equivalence for a linear \u3b3-calculus with explicit copying and algebraic effects \ue0 la Plotkin and Power. Such a calculus makes explicit the interaction between copying and linearity, which are intensional aspects of computation, with effects, which are, instead, extensional. We review some of the notions of equivalences for linear calculi proposed in the literature and show their limitations when applied to effectful calculi where copying is a first-class citizen. We then introduce resource transition systems, namely transition systems whose states are built over tuples of programs representing the available resources, as an operational semantics accounting for both intensional and extensional interactive behaviours of programs. Our main result is a sound and complete characterization of contextual equivalence as trace equivalence defined on top of resource transition systems
A Java-like calculus with heterogeneous coeffects
We propose a Java-like calculus where declared variables can be annotated by coeffects specifying constraints on their use, e.g., affinity or privacy levels. Such coeffects are heterogeneous, in the sense that different kinds of coeffects can be used in the same program; combining coeffects of different kinds leads to the trivial coeffect. We prove subject reduction, which includes preservation of coeffects, and show several examples. In a Java-like language, coeffects can be expressed in the language itself, as expressions of user-defined classes
π with Leftovers: a Mechanisation in Agda
Linear type systems need to keep track of how programs use their resources. The standard approach is to use context splits specifying how resources are (disjointly) split across subterms. In this approach, context splits redundantly echo information which is already present within subterms. An alternative approach is to use leftover typing [2, 23], where in addition to the usual (input) usage context, typing judgments have also an output usage context: the leftovers. In this approach, the leftovers of one typing derivation are fed as input to the next, threading through linear resources while avoiding context splits. We use leftover typing to define a type system for a resource-aware π -calculus [26, 27], a process algebra used to model concurrent systems. Our type system is parametrised over a set of usage algebras [20, 34] that are general enough to encompass shared types (free to reuse and discard), graded types (use exactly n number of times) and linear types (use exactly once). Linear types are important in the π -calculus: they ensure privacy and safety of communication and avoid race conditions, while graded and shared types allow for more flexible programming. We provide a framing theorem for our type system, generalise the weakening and strengthening theorems to include linear types, and prove subject reduction. Our formalisation is fully mechanised in about 1850 lines of Agda [37]