8,989 research outputs found
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
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
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
On external presentations of infinite graphs
The vertices of a finite state system are usually a subset of the natural
numbers. Most algorithms relative to these systems only use this fact to select
vertices.
For infinite state systems, however, the situation is different: in
particular, for such systems having a finite description, each state of the
system is a configuration of some machine. Then most algorithmic approaches
rely on the structure of these configurations. Such characterisations are said
internal. In order to apply algorithms detecting a structural property (like
identifying connected components) one may have first to transform the system in
order to fit the description needed for the algorithm. The problem of internal
characterisation is that it hides structural properties, and each solution
becomes ad hoc relatively to the form of the configurations.
On the contrary, external characterisations avoid explicit naming of the
vertices. Such characterisation are mostly defined via graph transformations.
In this paper we present two kind of external characterisations:
deterministic graph rewriting, which in turn characterise regular graphs,
deterministic context-free languages, and rational graphs. Inverse substitution
from a generator (like the complete binary tree) provides characterisation for
prefix-recognizable graphs, the Caucal Hierarchy and rational graphs. We
illustrate how these characterisation provide an efficient tool for the
representation of infinite state systems
A Linear Logic Programming Language for Concurrent Programming over Graph Structures
We have designed a new logic programming language called LM (Linear Meld) for
programming graph-based algorithms in a declarative fashion. Our language is
based on linear logic, an expressive logical system where logical facts can be
consumed. Because LM integrates both classical and linear logic, LM tends to be
more expressive than other logic programming languages. LM programs are
naturally concurrent because facts are partitioned by nodes of a graph data
structure. Computation is performed at the node level while communication
happens between connected nodes. In this paper, we present the syntax and
operational semantics of our language and illustrate its use through a number
of examples.Comment: ICLP 2014, TPLP 201
The promoters of human cell cycle genes integrate signals from two tumor suppressive pathways during cellular transformation
Deciphering regulatory events that drive malignant transformation represents
a major challenge for systems biology. Here we analyzed genome-wide
transcription profiling of an in-vitro transformation process. We focused on a
cluster of genes whose expression levels increased as a function of p53 and
p16INK4A tumor suppressors inactivation. This cluster predominantly consists of
cell cycle genes and constitutes a signature of a diversity of cancers. By
linking expression profiles of the genes in the cluster with the dynamic
behavior of p53 and p16INK4A, we identified a promoter architecture that
integrates signals from the two tumor suppressive channels and that maps their
activity onto distinct levels of expression of the cell cycle genes, which in
turn, correspond to different cellular proliferation rates. Taking components
of the mitotic spindle as an example, we experimentally verified our
predictions that p53-mediated transcriptional repression of several of these
novel targets is dependent on the activities of p21, NFY and E2F. Our study
demonstrates how a well-controlled transformation process allows linking
between gene expression, promoter architecture and activity of upstream
signaling molecules.Comment: To appear in Molecular Systems Biolog
Optimal Union-Find in Constraint Handling Rules
Constraint Handling Rules (CHR) is a committed-choice rule-based language
that was originally intended for writing constraint solvers. In this paper we
show that it is also possible to write the classic union-find algorithm and
variants in CHR. The programs neither compromise in declarativeness nor
efficiency. We study the time complexity of our programs: they match the
almost-linear complexity of the best known imperative implementations. This
fact is illustrated with experimental results.Comment: 12 pages, 3 figures, to appear in Theory and Practice of Logic
Programming (TPLP
- …