3,525 research outputs found
Workshop on Verification and Theorem Proving for Continuous Systems (NetCA Workshop 2005)
Oxford, UK, 26 August 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
Fast Automatic Verification of Large-Scale Systems with Lookup Tables
Modern safety-critical systems are difficult to formally verify, largely due to their large scale. In particular, the widespread use of lookup tables in embedded systems across diverse industries, such as aeronautics and automotive systems, create a critical obstacle to the scalability of formal verification. This paper presents a novel approach for the formal verification of large-scale systems with lookup tables. We use a learning-based technique to automatically learn abstractions of the lookup tables and use the abstractions to then prove the desired property. If the verification fails, we propose a falsification heuristic to search for a violation of the specification. In contrast with previous work on lookup table verification, our technique is completely automatic, making it ideal for deployment in a production environment. To our knowledge, our approach is the only technique that can automatically verify large-scale systems lookup with tables.
We illustrate the effectiveness of our technique on a benchmark which cannot be handled by the commercial tool SLDV, and we demonstrate the performance improvement provided by our technique
Evaluating Model Testing and Model Checking for Finding Requirements Violations in Simulink Models
Matlab/Simulink is a development and simulation language that is widely used
by the Cyber-Physical System (CPS) industry to model dynamical systems. There
are two mainstream approaches to verify CPS Simulink models: model testing that
attempts to identify failures in models by executing them for a number of
sampled test inputs, and model checking that attempts to exhaustively check the
correctness of models against some given formal properties. In this paper, we
present an industrial Simulink model benchmark, provide a categorization of
different model types in the benchmark, describe the recurring logical patterns
in the model requirements, and discuss the results of applying model checking
and model testing approaches to identify requirements violations in the
benchmarked models. Based on the results, we discuss the strengths and
weaknesses of model testing and model checking. Our results further suggest
that model checking and model testing are complementary and by combining them,
we can significantly enhance the capabilities of each of these approaches
individually. We conclude by providing guidelines as to how the two approaches
can be best applied together.Comment: 10 pages + 2 page reference
Automatic pipelining and vectorization of scientific code for FPGAs
There is a large body of legacy scientific code in use today that could benefit from execution on accelerator devices like GPUs and FPGAs. Manual translation of such legacy code into device-specific parallel code requires significant manual effort and is a major obstacle to wider FPGA adoption. We are developing an automated optimizing compiler TyTra to overcome this obstacle. The TyTra flow aims to compile legacy Fortran code automatically for FPGA-based acceleration, while applying suitable optimizations. We present the flow with a focus on two key optimizations, automatic pipelining and vectorization. Our compiler frontend extracts patterns from legacy Fortran code that can be pipelined and vectorized. The backend first creates fine and coarse-grained pipelines and then automatically vectorizes both the memory access and the datapath based on a cost model, generating an OpenCL-HDL hybrid working solution for FPGA targets on the Amazon cloud. Our results show up to 4.2× performance improvement over baseline OpenCL code
Automating Access Control Logics in Simple Type Theory with LEO-II
Garg and Abadi recently proved that prominent access control logics can be
translated in a sound and complete way into modal logic S4. We have previously
outlined how normal multimodal logics, including monomodal logics K and S4, can
be embedded in simple type theory (which is also known as higher-order logic)
and we have demonstrated that the higher-order theorem prover LEO-II can
automate reasoning in and about them. In this paper we combine these results
and describe a sound and complete embedding of different access control logics
in simple type theory. Employing this framework we show that the off the shelf
theorem prover LEO-II can be applied to automate reasoning in prominent access
control logics.Comment: ii + 20 page
Component-wise incremental LTL model checking
Efficient symbolic and explicit-state model checking
approaches have been developed for the verification of linear
time temporal
logic (LTL) properties. Several attempts have been made to
combine the advantages of the various algorithms. Model
checking LTL
properties usually poses two challenges: one must compute the
synchronous product of the state space and the automaton
model of the
desired property, then look for counterexamples that is
reduced to finding strongly connected components (SCCs) in
the state space
of the product. In case of concurrent systems, where the
phenomenon of state space explosion often prevents the
successful
verification, the so-called saturation algorithm has proved
its efficiency in state space exploration. This paper
proposes a new
approach that leverages the saturation algorithm both as an
iteration strategy constructing the product directly, as well
as in a
new fixed-point computation algorithm to find strongly
connected components on-the-fly by incrementally processing
the components
of the model. Complementing the search for SCCs, explicit
techniques and component-wise abstractions are used to prove
the absence
of counterexamples. The resulting on-the-fly, incremental LTL
model checking algorithm proved to scale well with the size
of
models, as the evaluation on models of the Model Checking
Contest suggests
- …