77 research outputs found
Rule-Based Software Verification and Correction
The increasing complexity of software systems has led to the development of sophisticated formal Methodologies for verifying and correcting data and programs. In general, establishing whether a program behaves correctly w.r.t. the original programmer s intention or checking the consistency and the correctness of a large set of data are not trivial tasks as witnessed by many case studies which occur in the literature.
In this dissertation, we face two challenging problems of verification and correction. Specifically, verification and correction of declarative programs, and the verification and correction of Web sites (i.e. large collections of semistructured data).
Firstly, we propose a general correction scheme for automatically correcting declarative, rule-based programs which exploits a combination of bottom-up as well as topdown inductive learning techniques. Our hybrid hodology is able to infer program corrections that are hard, or even impossible, to obtain with a simpler,automatic top-down or bottom-up learner. Moreover, the scheme will be also particularized to some well-known declarative programming paradigm: that is, the functional logic and the functional programming paradigm.
Secondly, we formalize a framework for the automated verification of Web sites which can be used to specify integrity conditions for a given Web site, and then automatically check whether these conditions are fulfilled. We provide a rule-based, formal specification language which allows us to define syntactic as well as semantic
properties of the Web site. Then, we formalize a verification technique which detects both incorrect/forbidden patterns as well as lack of information, that is, incomplete/missing Web pages. Useful information is gathered during the verification process which can be used to repair the Web site. So, after a verification phase, one
can also infer semi-automatically some possible corrections in order to fix theWeb site.
The methodology is based on a novel rewritBallis, D. (2005). Rule-Based Software Verification and Correction [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/194
Rewriting Logic Techniques for Program Analysis and Optimization
Esta tesis propone una metodologÃa de análisis dinámico que mejora el diagnóstico de programas erróneos escritos en el lenguaje Maude. La idea clave es combinar técnicas de verificación de aserciones en tiempo de ejecución con la fragmentación dinámica de trazas de ejecución para detectar automáticamente errores en tiempo de ejecución, al tiempo que se reduce el tamaño y la complejidad de las trazas a analizar. En el caso de violarse una aserción, se infiere automáticamente el criterio de fragmentación, lo que facilita al usuario identificar rápidamente la fuente del error.
En primer lugar, la tesis formaliza una técnica destinada a detectar automáticamente eventuales desviaciones del comportamiento deseado del programa (sÃntomas de error). Esta técnica soporta dos tipos de aserciones definidas por el usuario: aserciones funcionales (que restringen llamadas a funciones deterministas) y aserciones de sistema (que especifican los invariantes de estado del sistema). La técnica de verificación dinámica propuesta es demostrablemente correcta en el sentido de que todos los errores señalados definitivamente delatan la violación de las aserciones. Tras eventuales violaciones de aserciones, se generan automáticamente trazas fragmentadas (es decir, trazas simplificadas pero igualmente precisas) que ayudan a identificar la causa del error. Además, la técnica también sugiere una posible reparación para las reglas implicadas en la generación de los estados erróneos.
La metodologÃa propuesta se basa en (i) una notación lógica para especificar las aserciones que se imponen a la ejecución; (ii) una técnica de verificación aplicable en tiempo de ejecución que comprueba dinámicamente las aserciones; y (iii) un mecanismo basado en la generalización (ecuacional) menos general que automáticamente obtiene criterios precisos para fragmentar trazas de ejecución a partir de aserciones falsificadas.
Por último, se presenta una implementación de la técnica propuesta en la herramienta de análisis dinámico basado en aserciones ABETS, que muestra cómo es posible combinar el trazado
de las propiedades asertadas del programa para obtener un algoritmo preciso de análisis de trazas que resulta útil para el diagnóstico y la depuración de programas.This thesis proposes a dynamic analysis methodology for improving the diagnosis of erroneous Maude programs. The key idea is to combine runtime assertion checking and dynamic trace slicing for automatically catching errors at runtime while reducing the size and complexity of the erroneous traces to be analyzed (i.e., those leading to states that fail to satisfy the assertions). In the event of an assertion violation, the slicing criterion is automatically inferred, which facilitates the user to rapidly pinpoint the source of the error.
First, a technique is formalized that aims at automatically detecting anomalous deviations of the intended program behavior (error symptoms) by using assertions that are checked at runtime. This technique supports two types of user-defined assertions: functional assertions (which constrain deterministic function calls) and system assertions (which specify system state invariants). The proposed dynamic checking is provably sound in the sense that all errors flagged definitely signal a violation of the specifications. Then, upon eventual assertion violations, accurate trace slices (i.e., simplified yet precise execution traces) are generated automatically, which help identify the cause of the error. Moreover, the technique also suggests a possible repair for the rules involved in the generation of the erroneous states.
The proposed methodology is based on (i) a logical notation for specifying assertions that are imposed on execution runs; (ii) a runtime checking technique that dynamically tests the assertions; and (iii) a mechanism based on (equational) least general generalization that automatically derives accurate criteria for slicing from falsified assertions.
Finally, an implementation of the proposed technique is presented in the assertion-based, dynamic analyzer ABETS, which shows how the forward and backward tracking of asserted program properties leads to a thorough trace analysis algorithm that can be used for program diagnosis and debugging.Esta tesi proposa una metodologia d'anà lisi dinà mica que millora el diagnòstic de programes erronis escrits en el llenguatge Maude. La idea clau és combinar tècniques de verificació d'assercions en temps d'execució amb la fragmentació dinà mica de traces d'execució per a detectar automà ticament errors en temps d'execució, alhora que es reduïx la grandà ria i la complexitat de les traces a analitzar. En el cas de violar-se una asserció, s'inferix automà ticament el criteri de fragmentació, la qual cosa facilita a l'usuari identificar rà pidament la font de l'error.
En primer lloc, la tesi formalitza una tècnica destinada a detectar automà ticament eventuals desviacions del comportament desitjat del programa (sÃmptomes d'error). Esta tècnica suporta dos tipus d'assercions definides per l'usuari: assercions funcionals (que restringixen crides a funcions deterministes) i assercions de sistema (que especifiquen els invariants d'estat del sistema). La tècnica de verificació dinà mica proposta és demostrablement correcta en el sentit que tots els errors assenyalats definitivament delaten la violació de les assercions. Davant eventuals violacions d'assercions, es generen automà ticament traces fragmentades (és a dir, traces simplificades però igualment precises) que ajuden a identificar la causa de l'error. A més, la tècnica també suggerix una possible reparació de les regles implicades en la generació dels estats erronis.
La metodologia proposada es basa en (i) una notació lògica per a especificar les assercions que s'imposen a l'execució; (ii) una tècnica de verificació aplicable en temps d'execució que comprova dinà micament les assercions; i (iii) un mecanisme basat en la generalització (ecuacional) menys general que automà ticament obté criteris precisos per a fragmentar traces d'execució a partir d'assercions falsificades.
Finalment, es presenta una implementació de la tècnica proposta en la ferramenta d'anà lisi dinà mica basat en assercions ABETS, que mostra com és possible combinar el traçat cap avant i cap arrere de les propietats assertades del programa per a obtindre un algoritme precÃs d'anà lisi de traces que resulta útil per al diagnòstic i la depuració de programes.Sapiña Sanchis, J. (2017). Rewriting Logic Techniques for Program Analysis and Optimization [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/94044TESI
Correct Configuration of Process Variants in Provop
When engineering process-aware information systems (PAISs) one of the fundamental challenges is to cope with the variability of business processes. While some progress has been achieved regarding the configuration of process variants, there exists only little work on how to accomplish this in a correct manner. Configuring process variants constitutes a non-trivial challenge when considering the large number of process variants that exist in practice as well as the many syntactical and semantical constraints a configured process variant has to obey in a given context. In previous work we introduced the Provop approach for configuring and managing process variants. This paper picks up the Provop framework and shows how it ensures correctness of configurable process variants by construction. We discuss advanced concepts for the context- and constraint-based configuration of process variants, and show how they can be utilized to ensure correctness of the configured process variants. In this paper we also consider correctness issues in conjunction with dynamic variant re-configurations. Enhancing PAISs with the capability to correctly configure process models fitting to the given application context, and to correctly manage the resulting process variants afterwards, will enable a new quality in PAIS engineering
An Implementation of the Language Lambda Prolog Organized around Higher-Order Pattern Unification
This thesis concerns the implementation of Lambda Prolog, a higher-order
logic programming language that supports the lambda-tree syntax approach to
representing and manipulating formal syntactic objects. Lambda Prolog achieves
its functionality by extending a Prolog-like language by using typed lambda
terms as data structures that it then manipulates via higher-order unification
and some new program-level abstraction mechanisms. These additional features
raise new implementation questions that must be adequately addressed for Lambda
Prolog to be an effective programming tool. We consider these questions here,
providing eventually a virtual machine and compilation based realization. A key
idea is the orientation of the computation model of Lambda Prolog around a
restricted version of higher-order unification with nice algorithmic properties
and appearing to encompass most interesting applications. Our virtual machine
embeds a treatment of this form of unification within the structure of the
Warren Abstract Machine that is used in traditional Prolog implementations.
Along the way, we treat various auxiliary issues such as the low-level
representation of lambda terms, the implementation of reduction on such terms
and the optimized processing of types in computation. We also develop an actual
implementation of Lambda Prolog called Teyjus Version 2. A characteristic of
this system is that it realizes an emulator for the virtual machine in the C
language a compiler in the OCaml language. We present a treatment of the
software issues that arise from this kind of mixing of languages within one
system and we discuss issues relevant to the portability of our virtual machine
emulator across arbitrary architectures. Finally, we assess the the efficacy of
our various design ideas through experiments carried out using the system
Adjustment Strategies for Non-Compliant Process Instances
Enabling changes at both process type and process instance level is an essential requirement for any adaptive process-aware information system (PAIS). Particularly, it should be possible to migrate a (long-)running process instance to a new type schema version, even if this instance has been individually modified before. Further instance migration must not violate soundness; i.e., structural and behavorial consistency need to be preserved. Compliance has been introduced as basic notion to ensure that instances, whose state has progressed too far, are prohibited from being migrated. However, this also excludes them from further process optimizations, which is not tolerable in many practical settings. This paper introduces a number of strategies for coping with non-compliant instances in the context of process change such that they
can benefit from future process type changes on the one hand, but do not run into soundness problems on the other hand. We show, for example, how to automatically adjust process type changes at instance level to enable the migration of a higher number of instances. The different strategies are compared and discussed along existing approaches. Altogether, adequate treatment of non-compliant process instances contributes to full process lifecycle support in adaptive PAIS
A universal unification algorithm based on unification-driven leftmost outermost narrowing
We formalize a universal unification algorithm for the class of equational theories which is induced by the class of canonical, totally-defined, not strictly subunifiable term rewriting systems (for short: ctn-trs). For a ctn-trs R and for two terms t and s, the algorithm computes a ground-complete set of E_R-unifiers of t and s, where E_R is the set of rewrite rules of R viewed as equations. The algorithm is based on the unification-driven leftmost outermost narrowing relation (for short: ulo narrowing relation) which is introduced in this paper. The ulo narrowing relation combines usual leftmost outermost narrowing steps and unification steps. Since the unification steps are applied as early as possible, some of the nonsuccessful derivations can be stopped earlier than in other approaches to E_R-unification. Furthermore, we formalize a deterministic version of our universal unification algorithm that is based on a depth-first left-to-right traversal through the narrowing trees
Engineering an Advanced Location-Based Augmented Reality Engine for Smart Mobile Devices
Daily business routines more and more require to access information systems in a mobile manner, while preserving a desktop-like feeling at the same time. The goal of this work is to outline the engineering process of a sophisticated mobile service running on a smartphone. More precisely, we show how to develop the core of a location-based augmented reality engine for the iPhone 4S based on the operating system iOS 5.1 (or higher). We denote this engine as AREA. In particular, we develop concepts for coping with limited resources on a mobile device, while providing a smooth user augmented reality experience at the same time. We further present and develop a suitable application architecture in this context, which easily allows integrating augmented reality with a wide range of applications
- …