75,157 research outputs found
Context-Aware Separation Logic
Separation logic is often praised for its ability to closely mimic the
locality of state updates when reasoning about them at the level of assertions.
The prover only needs to concern themselves with the footprint of the
computation at hand, i.e., the part of the state that is actually being
accessed and manipulated. Modern concurrent separation logics lift this local
reasoning principle from the physical state to abstract ghost state. For
instance, these logics allow one to abstract the state of a fine-grained
concurrent data structure by a predicate that provides a client the illusion of
atomic access to the underlying state. However, these abstractions
inadvertently increase the footprint of a computation: when reasoning about a
local low-level state update, one needs to account for its effect on the
abstraction, which encompasses a possibly unbounded portion of the low-level
state. Often this gives the reasoning a global character.
We present context-aware separation logic (CASL) to provide new opportunities
for local reasoning in the presence of rich ghost state abstractions. CASL
introduces the notion of a context of a computation, the part of the concrete
state that is only affected on the abstract level. Contexts give rise to a new
proof rule that allows one to reduce the footprint by the context, provided the
computation preserves the context as an invariant. The context rule complements
the frame rule of separation logic by enabling more local reasoning in cases
where the predicate to be framed is known in advance. We instantiate our
developed theory for the flow framework, which enables local reasoning about
global properties of heap graphs. We then use the instantiation to obtain a
fully local proof of functional correctness for a sequential binary search tree
implementation that is inspired by fine-grained concurrent search structures
Segment Logic
O'Hearn, Reynolds and Yang introduced local Hoare reasoning about mutable data
structures using separation logic. They reason about the local parts of the memory
accessed by programs, and thus construct their smallest complete specifications.
Gardner et al. generalised their work, using context logic to reason about structured
data at the same level of abstraction as the data itself. In particular, we developed
a formal specification of the Document Object Model (DOM), a W3C XML update
library. Whilst we kept to the spirit of local reasoning, we were not able to retain
small specifications for all of the commands of DOM: for example, our specification
of the appendChild command was not small.
We show how to obtain such small specifications by developing a more fine-grained
context structure, allowing us to work with arbitrary segments of a data structure.
We introduce segment logic, a logic for reasoning about such segmented data structures, staring at first with a simple tree structure, but then showing how to generalise
our approach to arbitrary structured data.
Using our generalised segment logic we construct a reasoning framework for abstract program modules, showing how to reason about such modules at the client
level. In particular we look at modules for trees, lists, heaps and the more complex
data model of DOM.
An important part of any abstraction technique is an understanding of how to
link the abstraction back to concrete implementations. Building on our previous
abstraction and refinement work for local reasoning, we show how to soundly implement the segment models used in our abstract reasoning. In particular we show how
to implement our fine-grained list and tree modules so that their abstract specifications are satisfied by the concrete implementations. We also show how our reasoning
from the abstract level can be translated to reasoning at the concrete level.
Finally, we turn our attention to concurrency and show how having genuine small
axioms for our commands allows for a simple treatment of abstract level concurrency
constructs
Indexing the Event Calculus with Kd-trees to Monitor Diabetes
Personal Health Systems (PHS) are mobile solutions tailored to monitoring
patients affected by chronic non communicable diseases. A patient affected by a
chronic disease can generate large amounts of events. Type 1 Diabetic patients
generate several glucose events per day, ranging from at least 6 events per day
(under normal monitoring) to 288 per day when wearing a continuous glucose
monitor (CGM) that samples the blood every 5 minutes for several days. This is
a large number of events to monitor for medical doctors, in particular when
considering that they may have to take decisions concerning adjusting the
treatment, which may impact the life of the patients for a long time. Given the
need to analyse such a large stream of data, doctors need a simple approach
towards physiological time series that allows them to promptly transfer their
knowledge into queries to identify interesting patterns in the data. Achieving
this with current technology is not an easy task, as on one hand it cannot be
expected that medical doctors have the technical knowledge to query databases
and on the other hand these time series include thousands of events, which
requires to re-think the way data is indexed. In order to tackle the knowledge
representation and efficiency problem, this contribution presents the kd-tree
cached event calculus (\ceckd) an event calculus extension for knowledge
engineering of temporal rules capable to handle many thousands events produced
by a diabetic patient. \ceckd\ is built as a support to a graphical interface
to represent monitoring rules for diabetes type 1. In addition, the paper
evaluates the \ceckd\ with respect to the cached event calculus (CEC) to show
how indexing events using kd-trees improves scalability with respect to the
current state of the art.Comment: 24 pages, preliminary results calculated on an implementation of
CECKD, precursor to Journal paper being submitted in 2017, with further
indexing and results possibilities, put here for reference and chronological
purposes to remember how the idea evolve
Flexible Invariants Through Semantic Collaboration
Modular reasoning about class invariants is challenging in the presence of
dependencies among collaborating objects that need to maintain global
consistency. This paper presents semantic collaboration: a novel methodology to
specify and reason about class invariants of sequential object-oriented
programs, which models dependencies between collaborating objects by semantic
means. Combined with a simple ownership mechanism and useful default schemes,
semantic collaboration achieves the flexibility necessary to reason about
complicated inter-object dependencies but requires limited annotation burden
when applied to standard specification patterns. The methodology is implemented
in AutoProof, our program verifier for the Eiffel programming language (but it
is applicable to any language supporting some form of representation
invariants). An evaluation on several challenge problems proposed in the
literature demonstrates that it can handle a variety of idiomatic collaboration
patterns, and is more widely applicable than the existing invariant
methodologies.Comment: 22 page
COSMICAH 2005: workshop on verification of COncurrent Systems with dynaMIC Allocated Heaps (a Satellite event of ICALP 2005) - Informal Proceedings
Lisboa Portugal, 10 July 200
Reasoning with Forest Logic Programs and f-hybrid Knowledge Bases
Open Answer Set Programming (OASP) is an undecidable framework for
integrating ontologies and rules. Although several decidable fragments of OASP
have been identified, few reasoning procedures exist. In this article, we
provide a sound, complete, and terminating algorithm for satisfiability
checking w.r.t. Forest Logic Programs (FoLPs), a fragment of OASP where rules
have a tree shape and allow for inequality atoms and constants. The algorithm
establishes a decidability result for FoLPs. Although believed to be decidable,
so far only the decidability for two small subsets of FoLPs, local FoLPs and
acyclic FoLPs, has been shown. We further introduce f-hybrid knowledge bases, a
hybrid framework where \SHOQ{} knowledge bases and forest logic programs
co-exist, and we show that reasoning with such knowledge bases can be reduced
to reasoning with forest logic programs only. We note that f-hybrid knowledge
bases do not require the usual (weakly) DL-safety of the rule component,
providing thus a genuine alternative approach to current integration approaches
of ontologies and rules
- …