7 research outputs found
Discovering Business Processes models expressed as DNF or CNF formulae of Declare constraints
In the field of Business Process Management, the Process Discovery task is one of the most important and researched topics. It aims to automatically learn process models starting from a given set of logged execution traces. The majority of the approaches employ procedural languages for describing the discovered models, but declarative languages have been proposed as well. In the latter category there is the Declare language, based on the notion of constraint, and equipped with a formal semantics on LTLf. Also, quite common in the field is to consider the log as a set of positive examples only, but some recent approaches pointed out that a binary classification task (with positive and negative examples) might provide better outcomes. In this paper, we discuss our preliminary work on the adaptation of some existing algorithms for Inductive Logic Programming, to the specific setting of Process Discovery: in particular, we adopt the Declare language with its formal semantics, and the perspective of a binary classification task (i.e., with positive and negative examples
Inferring Properties in Computation Tree Logic
We consider the problem of automatically inferring specifications in the
branching-time logic, Computation Tree Logic (CTL), from a given system.
Designing functional and usable specifications has always been one of the
biggest challenges of formal methods. While in recent years, works have focused
on automatically designing specifications in linear-time logics such as Linear
Temporal Logic (LTL) and Signal Temporal Logic (STL), little attention has been
given to branching-time logics despite its popularity in formal methods. We
intend to infer concise (thus, interpretable) CTL formulas from a given finite
state model of the system in consideration. However, inferring specification
only from the given model (and, in general, from only positive examples) is an
ill-posed problem. As a result, we infer a CTL formula that, along with being
concise, is also language-minimal, meaning that it is rather specific to the
given model. We design a counter-example guided algorithm to infer a concise
and language-minimal CTL formula via the generation of undesirable models. In
the process, we also develop, for the first time, a passive learning algorithm
to infer CTL formulas from a set of desirable and undesirable Kripke
structures. The passive learning algorithm involves encoding a popular CTL
model-checking procedure in the Boolean Satisfiability problem
Specification sketching for Linear Temporal Logic
Virtually all verification and synthesis techniques assume that the formal specifications are readily available, functionally correct, and fully match the engineer's understanding of the given system. However, this assumption is often unrealistic in practice: formalizing system requirements is notoriously difficult, error-prone, and requires substantial training. To alleviate this severe hurdle, we propose a fundamentally novel approach to writing formal specifications, named specification sketching for Linear Temporal Logic (LTL). The key idea is that an engineer can provide a partial LTL formula, called an LTL sketch, where parts that are hard to formalize can be left out. Given a set of examples describing system behaviors that the specification should or should not allow, the task of a so-called sketching algorithm is then to complete a given sketch such that the resulting LTL formula is consistent with the examples. We show that deciding whether a sketch can be completed falls into the complexity class NP and present two SAT-based sketching algorithms. We also demonstrate that sketching is a practical approach to writing formal specifications using a prototype implementation
Learning Probabilistic Temporal Safety Properties from Examples in Relational Domains
We propose a framework for learning a fragment of probabilistic computation
tree logic (pCTL) formulae from a set of states that are labeled as safe or
unsafe. We work in a relational setting and combine ideas from relational
Markov Decision Processes with pCTL model-checking. More specifically, we
assume that there is an unknown relational pCTL target formula that is
satisfied by only safe states, and has a horizon of maximum steps and a
threshold probability . The task then consists of learning this unknown
formula from states that are labeled as safe or unsafe by a domain expert. We
apply principles of relational learning to induce a pCTL formula that is
satisfied by all safe states and none of the unsafe ones. This formula can then
be used as a safety specification for this domain, so that the system can avoid
getting into dangerous situations in future. Following relational learning
principles, we introduce a candidate formula generation process, as well as a
method for deciding which candidate formula is a satisfactory specification for
the given labeled states. The cases where the expert knows and does not know
the system policy are treated, however, much of the learning process is the
same for both cases. We evaluate our approach on a synthetic relational domain.Comment: 25 pages, 3 figures, 5 tables, 2 algorithms, preprin
Synthesizing Efficiently Monitorable Formulas in Metric Temporal Logic
In runtime verification, manually formalizing a specification for monitoring
system executions is a tedious and error-prone process. To address this issue,
we consider the problem of automatically synthesizing formal specifications
from system executions. To demonstrate our approach, we consider the popular
specification language Metric Temporal Logic (MTL), which is particularly
tailored towards specifying temporal properties for cyber-physical systems
(CPS). Most of the classical approaches for synthesizing temporal logic
formulas aim at minimizing the size of the formula. However, for efficiency in
monitoring, along with the size, the amount of "lookahead" required for the
specification becomes relevant, especially for safety-critical applications. We
formalize this notion and devise a learning algorithm that synthesizes concise
formulas having bounded lookahead. To do so, our algorithm reduces the
synthesis task to a series of satisfiability problems in Linear Real Arithmetic
(LRA) and generates MTL formulas from their satisfying assignments. The
reduction uses a novel encoding of a popular MTL monitoring procedure using
LRA. Finally, we implement our algorithm in a tool called TEAL and demonstrate
its ability to synthesize efficiently monitorable MTL formulas in a CPS
application
Process Discovery on Deviant Traces and Other Stranger Things
As the need to understand and formalise business processes into a model has grown over the last years, the process discovery research field has gained more and more importance, developing two different classes of approaches to model representation: procedural and declarative. Orthogonally to this classification, the vast majority of works envisage the discovery task as a one-class supervised learning process guided by the traces that are recorded into an input log.
In this work instead, we focus on declarative processes and embrace the less-popular view of process discovery as a binary supervised learning task, where the input log reports both examples of the normal system execution, and traces representing a “stranger” behaviour according to the domain semantics. We therefore deepen how the valuable information brought by both these two sets can be extracted and formalised into a model that is “optimal” according to user-defined goals. Our approach, namely NegDis, is evaluated w.r.t. other relevant works in this field, and shows promising results regarding both the performance and the quality of the obtained solution
Exact Synthesis of LTL Properties from Traces
We present an exact approach to synthesize temporal-logic formulas in linear temporal logic (LTL) from a set of given positive and negative example traces. Our approach uses topology structures, in particular partial DAGs, to partition the search space into small and manageable subproblems. The algorithm then solves each subproblem independently with the aid of an oracle for deciding satisfiability modulo propositional logic. This strategy is capable of achieving a super-linear speedup when parallelized. We have implemented a bounded synthesis approach to find an LTL formula of minimum size using the proposed topology-guided exact synthesis approach. In an experimental evaluation, we show that the proposed approach achieves a 20x runtime improvement over the state-of-the-art approach