6,448 research outputs found
Confluence Detection for Transformations of Labelled Transition Systems
The development of complex component software systems can be made more
manageable by first creating an abstract model and then incrementally adding
details. Model transformation is an approach to add such details in a
controlled way. In order for model transformation systems to be useful, it is
crucial that they are confluent, i.e. that when applied on a given model, they
will always produce a unique output model, independent of the order in which
rules of the system are applied on the input. In this work, we consider
Labelled Transition Systems (LTSs) to reason about the semantics of models, and
LTS transformation systems to reason about model transformations. In related
work, the problem of confluence detection has been investigated for general
graph structures. We observe, however, that confluence can be detected more
efficiently in special cases where the graphs have particular structural
properties. In this paper, we present a number of observations to detect
confluence of LTS transformation systems, and propose both a new confluence
detection algorithm and a conflict resolution algorithm based on them.Comment: In Proceedings GaM 2015, arXiv:1504.0244
A Decidable Confluence Test for Cognitive Models in ACT-R
Computational cognitive modeling investigates human cognition by building
detailed computational models for cognitive processes. Adaptive Control of
Thought - Rational (ACT-R) is a rule-based cognitive architecture that offers a
widely employed framework to build such models. There is a sound and complete
embedding of ACT-R in Constraint Handling Rules (CHR). Therefore analysis
techniques from CHR can be used to reason about computational properties of
ACT-R models. For example, confluence is the property that a program yields the
same result for the same input regardless of the rules that are applied.
In ACT-R models, there are often cognitive processes that should always yield
the same result while others e.g. implement strategies to solve a problem that
could yield different results. In this paper, a decidable confluence criterion
for ACT-R is presented. It allows to identify ACT-R rules that are not
confluent. Thereby, the modeler can check if his model has the desired
behavior.
The sound and complete translation of ACT-R to CHR from prior work is used to
come up with a suitable invariant-based confluence criterion from the CHR
literature. Proper invariants for translated ACT-R models are identified and
proven to be decidable. The presented method coincides with confluence of the
original ACT-R models.Comment: To appear in Stefania Costantini, Enrico Franconi, William Van
Woensel, Roman Kontchakov, Fariba Sadri, and Dumitru Roman: "Proceedings of
RuleML+RR 2017". Springer LNC
Justifications in Constraint Handling Rules for Logical Retraction in Dynamic Algorithms
We present a straightforward source-to-source transformation that introduces
justifications for user-defined constraints into the CHR programming language.
Then a scheme of two rules suffices to allow for logical retraction (deletion,
removal) of constraints during computation. Without the need to recompute from
scratch, these rules remove not only the constraint but also undo all
consequences of the rule applications that involved the constraint. We prove a
confluence result concerning the rule scheme and show its correctness. When
algorithms are written in CHR, constraints represent both data and operations.
CHR is already incremental by nature, i.e. constraints can be added at runtime.
Logical retraction adds decrementality. Hence any algorithm written in CHR with
justifications will become fully dynamic. Operations can be undone and data can
be removed at any point in the computation without compromising the correctness
of the result. We present two classical examples of dynamic algorithms, written
in our prototype implementation of CHR with justifications that is available
online: maintaining the minimum of a changing set of numbers and shortest paths
in a graph whose edges change.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
CHR(PRISM)-based Probabilistic Logic Learning
PRISM is an extension of Prolog with probabilistic predicates and built-in
support for expectation-maximization learning. Constraint Handling Rules (CHR)
is a high-level programming language based on multi-headed multiset rewrite
rules.
In this paper, we introduce a new probabilistic logic formalism, called
CHRiSM, based on a combination of CHR and PRISM. It can be used for high-level
rapid prototyping of complex statistical models by means of "chance rules". The
underlying PRISM system can then be used for several probabilistic inference
tasks, including probability computation and parameter learning. We define the
CHRiSM language in terms of syntax and operational semantics, and illustrate it
with examples. We define the notion of ambiguous programs and define a
distribution semantics for unambiguous programs. Next, we describe an
implementation of CHRiSM, based on CHR(PRISM). We discuss the relation between
CHRiSM and other probabilistic logic programming languages, in particular PCHR.
Finally we identify potential application domains
Data-Structure Rewriting
We tackle the problem of data-structure rewriting including pointer
redirections. We propose two basic rewrite steps: (i) Local Redirection and
Replacement steps the aim of which is redirecting specific pointers determined
by means of a pattern, as well as adding new information to an existing data ;
and (ii) Global Redirection steps which are aimed to redirect all pointers
targeting a node towards another one. We define these two rewriting steps
following the double pushout approach. We define first the category of graphs
we consider and then define rewrite rules as pairs of graph homomorphisms of
the form "L R". Unfortunately, inverse pushouts (complement pushouts)
are not unique in our setting and pushouts do not always exist. Therefore, we
define rewriting steps so that a rewrite rule can always be performed once a
matching is found
Conflict Detection for Edits on Extended Feature Models using Symbolic Graph Transformation
Feature models are used to specify variability of user-configurable systems
as appearing, e.g., in software product lines. Software product lines are
supposed to be long-living and, therefore, have to continuously evolve over
time to meet ever-changing requirements. Evolution imposes changes to feature
models in terms of edit operations. Ensuring consistency of concurrent edits
requires appropriate conflict detection techniques. However, recent approaches
fail to handle crucial subtleties of extended feature models, namely
constraints mixing feature-tree patterns with first-order logic formulas over
non-Boolean feature attributes with potentially infinite value domains. In this
paper, we propose a novel conflict detection approach based on symbolic graph
transformation to facilitate concurrent edits on extended feature models. We
describe extended feature models formally with symbolic graphs and edit
operations with symbolic graph transformation rules combining graph patterns
with first-order logic formulas. The approach is implemented by combining
eMoflon with an SMT solver, and evaluated with respect to applicability.Comment: In Proceedings FMSPLE 2016, arXiv:1603.0857
- …