Categories, Allegories, and Circuit Design

Languages based upon binary relations offer an appealing setting for constructing programs from specifications. For example, working with relations rather than functions allows specifications to be more abstract (for example, many programs have a natural specification using the converse operator on relations), and affords a natural treatment of non-determinism in specifications. In this paper we present a novel pictorial interpretation of relational terms as simple pictures of circuits, and a soundness/completeness result that allows relational equations to be proved by pictorial reasoning

Integrated specifications for abstract systems

Journal ArticleStructural specifications define an abstract object as a composition of other abstract objects. Behavioral specifications define an abstract object in terms of its associated operations. Integrated specifications are a combination of structural and behavioral specifications which are more powerful than either used alone. By providing four naming mechanisms, integrated specifications hide the details of how objects are represented and accessed on storage devices. The four naming mechanisms allow objects to be named in terms of the operations previously applied to them, the unique attributes they possess, the relationships they participate in, and the categories they belong to. Integrated specifications can specify the structure of more abstract systems than the relational database model, while also characterizing dynamic properties. Examples are given of integrated specifications for quide, symboltable and expression. These specifications are simple and guide, but do not constrain, the implementor in designing refinements. By exploiting abstract structure in specifications, common aspects of inter-object communication can be suppressed and only salient differences emphasized. Integrated specifications can make a significant contribution to the useability, reliability and efficiency of computer systems

Verification of Model Transformations

With the increasing use of automatic transformations of models, the correctness of these transformations becomes an increasingly important issue. Especially for model transformation generally defined using abstract description techniques like graph transformations or declarative relational specifications, however, establishing the soundness of those transformations by test-based approaches is not straight-forward. We show how formal verification of soundness conditions over such declarative relational style transformations can be performed using an interactive theorem prover. The relational style allows a direct translation of transformations as well as associated soundness conditions into corresponding axioms and theorems. Using the Isabelle theorem prover, the approach is demonstrated for a refactoring transformation and a connectedness soundness condition

Back to Basics: Deriving Representation Changers Functionally

Many functional programs can be viewed as representation changers, that is, as functions that convert abstract values from one concrete representation to another. Examples of such programs include base-converters, binary adders and multipliers, and compilers. In this paper we give a number of different approaches to specifying representation changers (pointwise, functional, and relational), and present a simple technique that can be used to derive functional programs from the specifications

ReLoC Reloaded:A Mechanized Relational Logic for Fine-Grained Concurrency and Logical Atomicity

We present a new version of ReLoC: a relational separation logic for proving refinements of programs with higher-order state, fine-grained concurrency, polymorphism and recursive types. The core of ReLoC is its refinement judgment $e \precsim e' : \tau$, which states that a program $e$ refines a program $e'$ at type $\tau$. ReLoC provides type-directed structural rules and symbolic execution rules in separation-logic style for manipulating the judgment, whereas in prior work on refinements for languages with higher-order state and concurrency, such proofs were carried out by unfolding the judgment into its definition in the model. ReLoC's abstract proof rules make it simpler to carry out refinement proofs, and enable us to generalize the notion of logically atomic specifications to the relational case, which we call logically atomic relational specifications. We build ReLoC on top of the Iris framework for separation logic in Coq, allowing us to leverage features of Iris to prove soundness of ReLoC, and to carry out refinement proofs in ReLoC. We implement tactics for interactive proofs in ReLoC, allowing us to mechanize several case studies in Coq, and thereby demonstrate the practicality of ReLoC. ReLoC Reloaded extends ReLoC (LICS'18) with various technical improvements, a new Coq mechanization, and support for Iris's prophecy variables. The latter allows us to carry out refinement proofs that involve reasoning about the program's future. We also expand ReLoC's notion of logically atomic relational specifications with a new flavor based on the HOCAP pattern by Svendsen et al

Mapping between Alloy specifications and database implementations

The emergence of lightweight formal methods tools such as Alloy improves the software design process, by encouraging developers to model and verify their systems before engaging in hideous implementation details. However, an abstract Alloy specification is far from an actual implementation, and manually refining the former into the latter is unfortunately a non-trivial task. This paper identifies a subset of the Alloy language that is equivalent to a relational database schema with the most conventional integrity constraints, namely functional and inclusion dependencies. This semantic correspondence enables both the automatic translation of Alloy specifications into relational database schemas and the reengineering of legacy databases into Alloy. The paper also discusses how to derive an object-oriented application layer to serve as interface to the underlying database

UNDERSTANDING PREPOSITIONS THROUGH COGNITIVE GRAMMAR. A CASE OF IN

Poly - semantic nature of prepositions has been discussed in linguistic literature and confirmed by language data. In the majority of research within cognitive linguistics prepositions have been approached as predicates organising entities in space, with less attention paid to the search for a meaning schema sanctioning the numerous uses. Cognitive Grammar analytic tools allow for the analysis which results in discovering one meaning schema sanctioning the uses of the English preposition in. The present analysis is based on the assumption that the meaning schema of in profiles a relation of conceptual enclosure between two symbolic structures, one of which conceptually fits in the other. Accordingly, I argue that the speaker employs in to structure a real scene not because one element of the scene can physically enclose the other one, but due to conceptual ‘fitting in’ holding between the predication ‘preceding’ the preposition and the one that ‘follows’. In formal terms, the usage of in is conditioned and sanctioned by compatibility of active zones in the predications used to form the complex language expression involved. Peculiarities of physical organization may be ignored in such conceptualisation, though the speaker can choose to encode all peculiarities of physical organisation of real world objects employing different linguistic devices

Reasoning about Computational Systems using Abella

International audienceWe present a tutorial on the Abella theorem prover that is designed to reason about relational specifications in higher-order abstract syntax