6,145 research outputs found
Contract-Based Specification Refinement and Repair for Mission Planning
We address the problem of modeling, refining, and repairing formal
specifications for robotic missions using assume-guarantee contracts. We show
how to model mission specifications at various levels of abstraction and
implement them using a library of pre-implemented specifications. Suppose the
specification cannot be met using components from the library. In that case, we
compute a proxy for the best approximation to the specification that can be
generated using elements from the library. Afterward, we propose a systematic
way to either 1) search for and refine the `missing part' of the specification
that the library cannot meet or 2) repair the current specification such that
the existing library can refine it. Our methodology for searching and repairing
mission requirements leverages the quotient, separation, composition, and
merging operations between contracts
A Metric for Linear Temporal Logic
We propose a measure and a metric on the sets of infinite traces generated by
a set of atomic propositions. To compute these quantities, we first map
properties to subsets of the real numbers and then take the Lebesgue measure of
the resulting sets. We analyze how this measure is computed for Linear Temporal
Logic (LTL) formulas. An implementation for computing the measure of bounded
LTL properties is provided and explained. This implementation leverages SAT
model counting and effects independence checks on subexpressions to compute the
measure and metric compositionally
Pacti: Scaling Assume-Guarantee Reasoning for System Analysis and Design
Contract-based design is a method to facilitate modular system design. While
there has been substantial progress on the theory of contracts, there has been
less progress on scalable algorithms for the algebraic operations in this
theory. In this paper, we present: 1) principles to implement a contract-based
design tool at scale and 2) Pacti, a tool that can efficiently compute these
operations. We then illustrate the use of Pacti in a variety of case studies
Hypercontracts
Contract theories have been proposed to formally support distributed and
decentralized system design while ensuring safe system integration. In this
paper we propose hypercontracts, a generic model with a richer structure for
its underlying model of components, subsuming simulation preorders. While this
new model remains generic, it provides a much more elegant and richer algebra
for its key notions of refinement, parallel composition, and quotient, and it
allows inclusion of new operations. On top of these foundations, we propose
conic hypercontracts, which are still generic but come with a finite
description
Moving from Specifications to Contracts in Component-Based Design
Abstract. Program properties that are automatically inferred by static analysis tools are generally not considered to be completely trustworthy, unless the tool implementation or the results are formally verified. Here we focus on the formal verification of resource guarantees inferred by automatic cost analysis. Resource guarantees ensure that programs run within the indicated amount of resources which may refer to memory consumption, to number of instructions executed, etc. In previous work we studied formal verification of inferred resource guarantees that depend only on integer data. In realistic programs, however, resource consumption is often bounded by the size of heap-allocated data structures. Bounding their size requires to perform a number of structural heap analyses. The contributions of this paper are (i) to identify what exactly needs to be verified to guarantee sound analysis of heap manipulating programs, (ii) to provide a suitable extension of the program logic used for verification to handle structural heap properties in the context of resource guarantees, and (iii) to improve the underlying theorem prover so that proof obligations can be automatically discharged.
Some Algebraic Aspects of Assume-Guarantee Reasoning
We present the algebra of assume-guarantee (AG) contracts. We define
contracts, provide new as well as known operations, and show how these
operations are related. Contracts are functorial: any Boolean algebra has an
associated contract algebra. We study monoid and semiring structures in
contract algebra -- and the mappings between such structures. We discuss the
actions of a Boolean algebra on its contract algebra
Contracts for Systems Design: Theory
Aircrafts, trains, cars, plants, distributed telecommunication military or health care systems,and more, involve systems design as a critical step. Complexity has caused system design times and coststo go severely over budget so as to threaten the health of entire industrial sectors. Heuristic methods andstandard practices do not seem to scale with complexity so that novel design methods and tools based on astrong theoretical foundation are sorely needed. Model-based design as well as other methodologies suchas layered and compositional design have been used recently but a unified intellectual framework with acomplete design flow supported by formal tools is still lacking.Recently an “orthogonal” approach has been proposed that can be applied to all methodologies introducedthus far to provide a rigorous scaffolding for verification, analysis and abstraction/refinement: contractbaseddesign. Several results have been obtained in this domain but a unified treatment of the topic that canhelp in putting contract-based design in perspective is missing. This paper intends to provide such treatmentwhere contracts are precisely defined and characterized so that they can be used in design methodologiessuch as the ones mentioned above with no ambiguity. In addition, the paper provides an important linkbetween interface and contract theories to show similarities and correspondences.This paper is complemented by a companion paper where contract based design is illustrated throughuse cases
The Quotient in Preorder Theories
Seeking the largest solution to an expression of the form A x <= B is a
common task in several domains of engineering and computer science. This
largest solution is commonly called quotient. Across domains, the meanings of
the binary operation and the preorder are quite different, yet the syntax for
computing the largest solution is remarkably similar. This paper is about
finding a common framework to reason about quotients. We only assume we operate
on a preorder endowed with an abstract monotonic multiplication and an
involution. We provide a condition, called admissibility, which guarantees the
existence of the quotient, and which yields its closed form. We call preordered
heaps those structures satisfying the admissibility condition. We show that
many existing theories in computer science are preordered heaps, and we are
thus able to derive a quotient for them, subsuming existing solutions when
available in the literature. We introduce the concept of sieved heaps to deal
with structures which are given over multiple domains of definition. We show
that sieved heaps also have well-defined quotients.Comment: In Proceedings GandALF 2020, arXiv:2009.0936
- …