Subtyping in alloy

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2004.Includes bibliographical references (p. 59-60).A type system for the Alloy modelling language is described that supports subtypes and allows overloading of relation names. No special syntactic features needed to be added to the language to support the type system; there are no casts, and the meaning of a model can be understood without reference to types. Type errors are associated with expressions that are irrelevant, in the sense that they can be replaced by an empty relation without affecting the value of their enclosing formula. Relevance is computed with an abstract interpretation that is relatively insensitive to standard algebraic manipulations. The typechecker for the system is presented in the context of Alloy Analyzer 3.0. Its architecture is explained in terms of key data abstractions, algorithms, and complexity analyses.by Emina Torlak.M.Eng

SAVCBS 2004 Specification and Verification of Component-Based Systems: Workshop Proceedings

This is the proceedings of the 2004 SAVCBS workshop. The workshop is concerned with how formal (i.e., mathematical) techniques can be or should be used to establish a suitable foundation for the specification and verification of component-based systems. Component-based systems are a growing concern for the software engineering community. Specification and reasoning techniques are urgently needed to permit composition of systems from components. Component-based specification and verification is also vital for scaling advanced verification techniques such as extended static analysis and model checking to the size of real systems. The workshop considers formalization of both functional and non-functional behavior, such as performance or reliability

ABSTRACT Faster Constraint Solving with Subtypes

Constraints in predicate or relational logic can be translated into boolean logic and solved with a SAT solver. For faster solving, it is common to exploit the typing of predicates or relations, in order to reduce the number of boolean variables needed to encode the constraint. Here we show how to extend this idea to constraints expressed in a language with subtyping. Our technique, called atomization, refactors the type hierarchy into a flat collection of disjoint atomic types. The constraints are then decomposed into equivalent constraints involving smaller relations or predicates over these new types, which can then be solved in the normal fashion. Experiments with an implementation of this technique within the Alloy Analyzer show improved performance on practical software checking problems