70,811 research outputs found
Efficient Large-scale Trace Checking Using MapReduce
The problem of checking a logged event trace against a temporal logic
specification arises in many practical cases. Unfortunately, known algorithms
for an expressive logic like MTL (Metric Temporal Logic) do not scale with
respect to two crucial dimensions: the length of the trace and the size of the
time interval for which logged events must be buffered to check satisfaction of
the specification. The former issue can be addressed by distributed and
parallel trace checking algorithms that can take advantage of modern cloud
computing and programming frameworks like MapReduce. Still, the latter issue
remains open with current state-of-the-art approaches.
In this paper we address this memory scalability issue by proposing a new
semantics for MTL, called lazy semantics. This semantics can evaluate temporal
formulae and boolean combinations of temporal-only formulae at any arbitrary
time instant. We prove that lazy semantics is more expressive than standard
point-based semantics and that it can be used as a basis for a correct
parametric decomposition of any MTL formula into an equivalent one with
smaller, bounded time intervals. We use lazy semantics to extend our previous
distributed trace checking algorithm for MTL. We evaluate the proposed
algorithm in terms of memory scalability and time/memory tradeoffs.Comment: 13 pages, 8 figure
An extended interval temporal logic and a framing technique for temporal logic programming
PhD ThesisTemporal logic programming is a paradigm for specification and verification of concurrent programs
in which a program can be written, and the properties of the program can be described
and verified in a same notation. However, there are many aspects of programming in temporal
logics that are not well-understood. One such an aspect is concurrent programming, another is
framing and the third is synchronous communication for parallel processes.
This thesis extends the original Interval Temporal Logic (ITL) to include infinite models,
past operators, and a new projection operator for dealing with concurrent computation, synchronous
communication, and framing in the context of temporal logic programming.
The thesis generalizes the original ITL to include past operators such as previous and past
chop, and extends the model to include infinite intervals. A considerable collection of logic laws
regarding both propositional and first order logics is formalized and proved within model theory.
After that, a subset of the extended ITL is formalized as a programming language, called
extended Tempura. These extensions, as in their logic basis, include infinite models, the previous
operator, projection and framing constructs. A normal form for programs within the extended
Tempura is demonstrated.
Next, a new projection operator is introduced. In the new construct, the sub-processes are
autonomous; each process has the right to specify its own interval over which it is executed.
The thesis presents a framing technique for temporal logic programming, which includes the
definitions of new assignments, the assignment flag and the framing operator, the formalization
of algebraic properties of the framing operator, the minimal model semantics of framed programs,
as well as an executable framed interpreter.
The synchronous communication operator await is based directly on the proposed framing
technique. It enables us to deal with concurrent computation. Based on EITL and await
operator, a framed concurrent temporal logic programming language, FTLL, is formally defined
within EITL.
Finally, the thesis describes a framed interpreter for the extended Tempura which has been
developed in SICSTUS prolog. In the new interpreter, the implementation of new assignments,
the frame operator, the await operator, and the new projection operator are all included
Fifty years of Hoare's Logic
We present a history of Hoare's logic.Comment: 79 pages. To appear in Formal Aspects of Computin
Applying Formal Methods to Networking: Theory, Techniques and Applications
Despite its great importance, modern network infrastructure is remarkable for
the lack of rigor in its engineering. The Internet which began as a research
experiment was never designed to handle the users and applications it hosts
today. The lack of formalization of the Internet architecture meant limited
abstractions and modularity, especially for the control and management planes,
thus requiring for every new need a new protocol built from scratch. This led
to an unwieldy ossified Internet architecture resistant to any attempts at
formal verification, and an Internet culture where expediency and pragmatism
are favored over formal correctness. Fortunately, recent work in the space of
clean slate Internet design---especially, the software defined networking (SDN)
paradigm---offers the Internet community another chance to develop the right
kind of architecture and abstractions. This has also led to a great resurgence
in interest of applying formal methods to specification, verification, and
synthesis of networking protocols and applications. In this paper, we present a
self-contained tutorial of the formidable amount of work that has been done in
formal methods, and present a survey of its applications to networking.Comment: 30 pages, submitted to IEEE Communications Surveys and Tutorial
A logic programming framework for modeling temporal objects
Published versio
Some Challenges of Specifying Concurrent Program Components
The purpose of this paper is to address some of the challenges of formally
specifying components of shared-memory concurrent programs. The focus is to
provide an abstract specification of a component that is suitable for use both
by clients of the component and as a starting point for refinement to an
implementation of the component. We present some approaches to devising
specifications, investigating different forms suitable for different contexts.
We examine handling atomicity of access to data structures, blocking operations
and progress properties, and transactional operations that may fail and need to
be retried.Comment: In Proceedings Refine 2018, arXiv:1810.0873
Modelling Garbage Collection Algorithms --- Extend abstract
We show how abstract requirements of garbage collection can be captured using temporal logic. The temporal logic specification can then be used as a basis for process algebra specifications which can involve varying amounts of parallelism. We present two simple CCS specifications as an example, followed by a more complex specification of the cyclic reference counting algorithm. The verification of such algorithms is then briefly discussed
Answer Set Programming Modulo `Space-Time'
We present ASP Modulo `Space-Time', a declarative representational and
computational framework to perform commonsense reasoning about regions with
both spatial and temporal components. Supported are capabilities for mixed
qualitative-quantitative reasoning, consistency checking, and inferring
compositions of space-time relations; these capabilities combine and synergise
for applications in a range of AI application areas where the processing and
interpretation of spatio-temporal data is crucial. The framework and resulting
system is the only general KR-based method for declaratively reasoning about
the dynamics of `space-time' regions as first-class objects. We present an
empirical evaluation (with scalability and robustness results), and include
diverse application examples involving interpretation and control tasks
- …