Algebra of programming
Universal coalgebra: a theory of systems
Theoretical Computer Science - Modern algebra and its applications
A Typed Lambda Calculus with Categorical Type Constructors
Category Theory and Computer Science
Abstract State Machines: A Method for High-Level System Design and Analysis
Abstract State Machines: A Method for High-Level System Design and Analysis
Components as coalgebras: the refinement dimension
Theoretical Computer Science - Algebraic methodology and software technology
Transposing partial components: an exercise on coalgebraic refinement
Theoretical Computer Science - Components and objects
Calculating Invariants as Coreflexive Bisimulations
AMAST 2008 Proceedings of the 12th international conference on Algebraic Methodology and Software Technology
Extended Static Checking by Calculation Using the Pointfree Transform
Language Engineering and Rigorous Software Development
Towards the introduction of QoS information in a component model
Proceedings of the 2010 ACM Symposium on Applied Computing
| Hi-index | 0.00 |
Invariants are constraints on software components which restrict their behavior in some desirable way, but whose maintenance entails some kind of proof obligation discharge. Such constraints may act not only over the input and output domains, as in a purely functional setting, but also over the underlying state space, as in the case of reactive components. This talk introduces an approach for reasoning about invariants which is both compositional and calculational: compositional because it is based on rules which break the complexity of such proof obligations across the structures involved; calculational because such rules are derived thanks to an algebra of invariants encoded in the language of binary relations. A main tool of this approach is the pointfree transform of the predicate calculus, which opens the possibility of changing the underlying mathematical space so as to enable agile algebraic calculation. The development of a theory of invariant preservation requires a broad, but uniform view of computational processes embodied in software components able to take into account data persistence and continued interaction. Such is the plan for this talk: we first introduce such processes as arrows, and then invariants as their types.