10 Years Playing with Declare and Temporal Logics on Finite Traces

s
10 years playing with Declare
and temporal logics
over ﬁnite
traces
marco montali
free university of bozen-bolzano
TU/e
14/05/2019
RWTH
16/05/2019

Types of Processes
Not all business processes are the same
• Even within one organization, business processes can be
very different in terms of their essential properties.
• Business processes can be characterized through three
dimensions:
• complexity
• predictability
• repetitiveness

Flexibility vs Control
Flexibility: degree to which users can make local
decisions about how to execute processes.
Control: degree to which a system makes
centralized decisions about how to execute
processes. Universe of Traces
Compliant
Traces
Flexibility

Trends in BPM
modeling
• Variable BPs
• Metaphor: rules/constraints
Dec t i
lar
a
ev
Imperative modeling
• Traditional, repetitive BPs
• Metaphor: ﬂow-chart

Goal Today
diagnosis/
requirements
conﬁguration/
implementation
(re)design
enactment/
monitoring
models
data
1. Introduce declarative,
constraint-based
processes
2. Show how they can be
formalized using temporal
logics over ﬁnite traces
3. Show how corresponding
automata-theoretic
techniques can be used to
elegantly support the
entire lifecycle of such
processes

Imperative Modeling
Focus: howthings must be done
• Explicit description of the process control-ﬂow
Closedmodeling
• All that is not explicitly modeled is forbidden
• Exceptions/uncommon behaviors have to be
explicitly enumerated at design time

BPMN
Receive
order
Check
availability
Article available?
Ship article
Financial
settlement
yes
Procurement
no
Payment
received
Inform
customer
Late deliveryUndeliverable
Customer
informed
Inform
customer
Article
removed
Remove
article from
catalogue

Receive
order
Check
availability
Article available?
Ship article
Financial
settlement
yes
Procurement
no
Payment
received
Inform
customer
Customer
informed
Inform
customer
Article
removed
Remove
article from
catalogue
Input Output
BPMN

BPMN
Receive
order
Check
availability
Article available?
Ship article
Financial
settlement
yes
Procurement
no
Payment
received
Inform
customer
Customer
informed
Inform
customer
Article
removed
Remove
article from
catalogue
Input Output

What is your
Favourite Italian Food?
Order-to-delivery

What is your
Favourite Italian Food?
UnderstandingSpaghettiModelswithSequenceClusteringforProM9
thoseexceptions.Figure4depictstheresultofaﬁrstattempttoanalyzethe
applicationserverlogsusingtheheuristicsminer[4].
Exception
(complete)
187
EstabelecimentoNotFoundException
(complete)
187
0,991
152
GREJBPersistencyException
(complete)
179
0,909
159
PGWSException
(complete)
168
0,889
12
ITPTExternalServiceException
(complete)
183
0,944
162
SIPSCNoRecordsFoundException
(complete)
160
0,8
5
PessoaSingularNotFoundException
(complete)
138
0,667
3
BusinessLogicException
(complete)
183
0,75
4
SICCLException
(complete)
175
0,857
19
NaoExistemRegistosException
(complete)
143
0,833
6
RPCBusinessException
(complete)
38
0,75
3
SAFBusinessException
(complete)
115
0,8
68
GREJBBusinessException
(complete)
45
0,75
23
DESWSException
(complete)
14
0,667
14
NullPointerException
(complete)
104
0,8
91
ValidationException
(complete)
31
0,8
12
GILBusinessException
(complete)
14
0,5
6
GRServicesException
(complete)
7
0,667
3
CSIBusinessException
(complete)
14
0,5
6
ConcorrenciaException
(complete)
5
0,5
2
CSIPersistencyException
(complete)
3
0,5
2
0,857
34
ITPTServerException
(complete)
21
0,667
15
COOPException
(complete)
4
0,5
2
RSIValidationException
(complete)
25
0,667
18
BasicSystemException
(complete)
16
0,667
11
PesquisaAmbiguaException
(complete)
6
0,5
6
CPFBusinessException
(complete)
3
0,5
2
0,8
95
ADOPException
(complete)
6
0,5
5
AFBusinessException
(complete)
64
SIPSCRemoteBusinessException
(complete)
51
0,833
13
ConcurrentModificationException
(complete)
5
0,5
1
CDFBusinessException
(complete)
6
0,667
2
AssinaturaNaoIncluidaException
(complete)
1
0,5
1
SICCSException
(complete)
32
0,8
11
CartaoCidadaoException
(complete)
64
0,833
38
SOAPException
(complete)
22
0,667
14
TooManyRowsException
(complete)
112
0,667
18
SIPSCFatalException
(complete)
20
0,667
9
LimiteTemporalException
(complete)
4
0,5
2
0,8
28
SVIBusinessUserException
(complete)
18
0,75
12
GRConcurrencyException
(complete)
8
0,5
2
ContribuinteRegionalNotFoundException
(complete)
63
0,75
30
JDOFatalUserException
(complete)
124
0,947
49
0,667
5
SQLException
(complete)
9
0,667
7
IOException
(complete)
27
0,75
22
PessoaColectivaNotFoundException
(complete)
23
0,75
20
ServiceDelegateRemoteException
(complete)
3
0,5
2
0,5
5
PASException
(complete)
2
0,5
1
FileNotFoundException
(complete)
31
0,75
13
QgenMIParametrizedBusinessException
(complete)
1
0,5
1
ADOPMessageException
(complete)
3
0,5
2
LayoffException
(complete)
1
0,5
1
0,75
8
CMPException
(complete)
1
0,5
1
GREJBRemoteServiceException
(complete)
34
0,75
4
RSIPersistenceException
(complete)
24
0,75
4
CSIRemoteException
(complete)
3
0,5
1
SIPSCFatalRemoteCallException
(complete)
3
0,5
1
SIPSCDatabaseException
(complete)
1
0,5
1
BusinessException
(complete)
159
0,667
9
SVIBusinessException
(complete)
1
0,5
1
ParametrizedBusinessException
(complete)
2
0,5
2
GDServicesException
(complete)
4
0,5
3
ServerException
(complete)
132
0,75
16
PGException
(complete)
6
0,667
5
0,75
4
DESException
(complete)
135
0,667
13
0,667
2
0,75
9
SIPSCException
(complete)
27
0,75
9
ReportException
(complete)
5
0,667
2
SSNServiceException
(complete)
1
0,5
1
AFException
(complete)
1
0,5
1
InvalidNISSException
(complete)
14
0,75
4
0,75
14
GILConcurrencyException
(complete)
1
0,5
1
RSISystemException
(complete)
28
0,75
7
0,667
5
0,667
1
0,75
2
0,667
5
0,833
5
0,667
5
0,667
4
0,75
12
0,981
53
ADOPUserChoiceException
(complete)
1
0,5
1
0,667
5
RPCException
(complete)
1
0,5
1
GREJBConcurrencyException
(complete)
15
0,875
8
0,5
1
0,5
1
0,667
1
MoradaPortuguesaNotFoundException
(complete)
1
0,5
1
0,75
4
0,5
1
0,667
6
0,5
1
0,5
2
0,889
8
0,75
3
0,8
3
RSIException
(complete)
1
0,5
1
0,5
1
0,5
1
0,667
4
0,667
3
0,5
1
0,5
2
0,75
5
0,5
1
0,5
1
0,5
2
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,5
1
0,8
1
0,5
1
0,5
1
0,5
1
Fig.4.Spaghettimodelobtainedfromtheapplicationserverlogsusingtheheuristics
miner.
Usingthesequenceclusteringplug-inanditspreprocessingcapabilities,as
wellasthepossibilityofvisuallyadjustingtheclustermodelsaccordingtocertain
Healthcare

Choreography Example
• An order can be finalized at most once
• Once an order is finalized, it must be confirmed or rejected
• A confirmed order may be rejected later on (due to “late”
problems), but not vice-versa: a rejection cannot be reverted.
• An order can be confirmed only if it shipped before.
• An order may be rejected autonomously by the seller.
However, if the warehouse notifies the seller of a shipment
issue, then the seller has to reject the order.
• The warehouse decision is firm: “Ship” and “Notify shipment
issue” are mutually exclusive.

Our Goal
represents
Reality
Model

Constraint-Based Modeling
Focus: whathas to be accomplished
• Explicit description of the relevant business constraints
• behavioral constraints, best practices, norms, rules, …
Openmodeling
• All behaviors are possible unless they are explicitly
forbidden
• Control-ﬂow left implicit

Declare
• A constraint-based extensible language  
for ﬂexible process modeling
• An execution engine for constraint-based
processes 
http://www.win.tue.nl/declare/
• Originally proposed by Pesic and van der  
Aalst
• Formalized by Pesic and van der Aalst,  
and by _

Modeling in Declare
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue

0..1
Modeling in Declare
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
An order can be
ﬁnalized at most once

0..1
Modeling in Declare
Finalize order
Confirm
order
Reject
order
Ship
Notify
shipment issue
Once an order is finalized, it must
be confirmed or rejected

0..1
Modeling in Declare
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
precedence…

0..1
Modeling in Declare
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
A conﬁrmed order may be rejected
later on, but not vice-versa

0..1
Modeling in Declare
Finalize order
Confirm
order
Reject
order
Ship
Notify
shipment issue
if the warehouse notifies the seller of a shipment issue,
then the seller has to reject the order
An order can be confirmed only if it
shipped before

0..1
Modeling in Declare
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
Mutually
exclusive

The Origin of Declare…
Patterns in
Linear
Temporal
Logic

Linear Temporal Logic (LTL)
…
' ::= A | ¬' | '1 ^ '2 | ' | '1U'2
Atomic propositions
Boolean connectives
At next step φ holds
Eventually φ2 holds, and φ1 holds until φ2 does
φ eventually holds
φ always holds
φ1 holds forever or until φ2 does
Models:  
inﬁnite traces
' ::= A | ¬' | '1 ^ '2 | ' | '1U'2
' ::= A | ¬' | '1 ^ '2 | ' | '1U'2
| '1 ^ '2 | ' | '1U'2
'2 | ' | '1U'2
⌃' ⌘ true U'
⇤' ⌘ ¬⌃¬'
'1W'2 = '1U'2 _ ⇤'1⇤' ⌘ ¬⌃¬'

Formalizing Declare
• Tasks as propositions
• At each moment, only one task is executed
• Each Declare template becomes an LTL pattern
ba
ba
ba
…
¬bWa
¬(⌃a ^ ⌃b)
⇤(a ! ⌃b)

Formalizing Declare
A Declare model becomes an “LTL” formula:
• Conjunction of all constraint formulae
• Constraint formula grounds “LTL” template on its tasks

Formalizing Declare
moored
under way
using engine
under way
sailing
constrained by
her draught

Formalizing Declare
moored
under way
using engine
under way
sailing
constrained by
her draught
⇤(m ! ⌃e)
^¬(⌃e ^ ⌃s)
^¬cWs

Not so Simple…
LTL ⇤(m ! ⌃e)

Not so Simple…
LTL
Each process instance
eventually terminates!

Not so Simple…
LTL
Each process instance
eventually terminates!
Models:  
ﬁnite traces
LTLf

Interestingly, in AI…
Extensive adoption of linear temporal logics in reasoning about
actions and planning
Finite vs infinite semantics, often blurring this distinction…
• Temporally extended goals [BacchusKabanza96]: infinite/finite
• Trajectory constraints [PDDL 3.0]: finite
• Declarative control knowledge on trajectories [BaierMcIlraith06]:
finite
• Procedural control knowledge on trajectories
[BaierFritzMcIlraith07]: finite
• Temporal specifications in planning domains
[CalvaneseDeGiacomoVardi02]: infinite
• Planning via model checking [DeGiacomoVardi99]: finite

Linear Temporal Logic over
Finite Traces (LTLf)
' ::= A | ¬' | '1 ^ '2 | ' | '1U'2
Models:  
ﬁnite traces
Same syntax of LTL, but different semantics!
In LTL, there is always a next moment… in LTLf, no!
φ always holds from current to the last instant
The next step exists and at next step φ holds
(weak next)
If the next step exists, then at next step φ holds
last instant in the trace
'1 ^ '2 | ' | '1U'2
⇤'
Last ⌘ ¬ true
' ⌘ ¬ ¬'

Inﬁnite vs Finite Traces
⇤(a ! ⌃b)

⇤(a ! ⌃b)
On inﬁnite traces
b a b …
…a …

b aa b
⇤(a ! ⌃b)
On inﬁnite traces
On ﬁnite traces
b a b …
…a …

⇤(a ! ⌃b) ^ ⇤(b ! ⌃a)

On inﬁnite traces
⇤(a ! ⌃b) ^ ⇤(b ! ⌃a)
b a b …
…a a b…

On inﬁnite traces
On ﬁnite traces
⇤(a ! ⌃b) ^ ⇤(b ! ⌃a)
b aa
b a b …
…a a b…
b
a
(inconsistent 
in Declare!)

Büchi automaton accepting  
its inﬁnite traces
NFA accepting  
its ﬁnite traces
⇤(a ! ⌃b) ^ ⇤(b ! ⌃a)
22 A. Russo – Constraint-based Declarative Processes
S0
S1 S2
S3
!A ∧ !B
A ∧ B!A
B
A ∧ B
A ∧ B
true
true
trueA ∧ B
B
A
B
S1S0
trueA ∧ B
!A ∧ !B
A ∧ B
true
S0
!A ∧ !B
A B
response
response
a) Constraint model b) Buchi automaton
true
C

Look the Same, not the Same
Many researchers: misled by the lift from infinite to finite traces
• Naive approach to LTLf: LTL interpreted over a trace where
eventually nothing happens (keeping the input formula unaltered)
In [De Giacomo, De Masellis, _, AAAI2014], we studied why!
• People typically focus on “patterns”, not on the entire logic
• Many LTL patterns in BPM, reasoning about actions, planning, etc.
are “insensitive to infinity”: naive approach works!

Formal Properties of LTLf
• Expressiveness: FO over finite traces, i.e., star-free RE
• Reasoning: satisfiability, validity, logical implication
PSPACE-complete
• Model checking: linear in the TS, PSPACE-complete in
the formula
Hence, reasoning/model checking as difficult as in the
infinite-trace case… but there is a catch!

Main Catch
LTLf NFA 
nondeterministic
DFA 
deterministic
LTLf2aut determin.
'
Reasoning can be carried out with automata on ﬁnite words!can be translated into equivalent nfa:
t |= Ï i t œ L(AÏ)
nfa (exponential)
ponential)
dfa corresponding to ltlf /ldlf are in fact small!
oning into automata based procedures!
Can be implemented
and run!
[De Giacomo et al., BPM 2014]

Our Vision… Realized!
'
LTLf NFA 
nondeterministic
DFA 
deterministic
LTLf2aut determin.

Examples of DFAs
ba ⇤(a ! ⌃b)
00 1
a
b
not a not b

Examples of DFAs
ba ¬bWa
0
a
b
not {a,b}
true1
2 true

Examples of DFAs
ba ¬(⌃a ^ ⌃b)
a
b
not b
true00
not {a,b}
1
2
3
b
a
not b
1
2

Correctness Veriﬁcation
diagnosis/
requirements
conﬁguration/
implementation
enactment/
monitoring
data
(re)design
models

Example
1..*
a b
INCORRECT
(ﬁnite traces)

0..1
Example
a c
b
dead activity

Correctness
• In BPM: typically assessed via model checking
• In the case of Declare: satisﬁability
• Correct Declare model: admits a trace
satisfying all constraints
• (i.e., its LTLf formula) is satisﬁable
• How to check?  
Language emptiness of the corresponding NFA

(re)design
models
diagnosis/
requirements
conﬁguration/
implementation
data
enactment/
monitoring
Enactment and Monitoring

Enactment of a Process
1. History recognition: given the
history of a running instance,
compute the current state (or reject)  
2. Todo list: given the current state, tell  
which tasks can(not) be executed
next 
(including possibility of termination) 
3. Update: given a state and a task, 
determine the new state
S
a
b
c
S
SnewS
a
initial

Execution
0..1
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue

Initial Situation
0..1
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
May complete now…

“Finalize Order”
0..1
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue

“Notify Shipment Issue”
0..1
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue

“Reject Order”
0..1
Finalize order
Conﬁrm
order
Reject
order
Ship
Notify
shipment issue
May complete now…

Hidden Dependencies
Ship
Notify
shipment issue
Pick package Insert material Close package

Initial State
Ship
Notify
shipment issue
May complete now…

Initial State
Ship
Notify
shipment issue
What if I execute this?
May complete now…

“Notify Shipment Issue”
Ship
Notify
shipment issue
!!!
May complete now…

…
…
…
RV-LTL Truth Values
Refined analysis of the “truth
value” of a constraint, looking into
(all) possible futures
Consider a partial trace t, and a
constraint C
t
C
satisfied?
……
C
satisfied?

RV-LTL Truth Values
• C is permanently satisfied if t
satisfies C and no matter how t is
extended, C will stay satisfied
• C is temporarily satisfied if t
satisfies C but there is a
continuation of t that violates C
…
…
t
…
…
…
t

RV-LTL Truth Values
• C is temporarily violated if t
violates C but there is a
continuation that leads to satisfy C
• C is permanently violated if t
violates C and no matter how t is
extended, C will stay violated
t
…
…
…
…
…

How to Construct
RV-LTL Monitors?
In the literature…
• Ad-hoc extensions of the standard automata-
theretic characterization of linear temporal
logics
• Mainly studied for LTL over infinite traces: a
partial trace is a prefix of an infinite suffix
• Can be adjusted to LTLf, but they require
anyway a detour tu Büchi automata

A Key Observation
Suitability of the Constraint Speciﬁcation Language
ltlf
FOL over
ﬁnite traces
Star-free
regular
expressions

ldlf
Linear Dynamic
Logic over
finite traces
ltlf
MSOL over
finite traces
FOL over
finite traces
Regular
expressions
Star-free
regular
expressions
pspace
complexity
Nondet.
finite-state
automata
(nfa)
• ltlf : declarative, but lacking expressiveness.
• Regular expressions: rich formalism, but low-level.
(t)ake-off (r)each ((r|other)ú
(t(t|other)ú
r)(r|other)ú
)ú
A Key Observation
ltlf
FOL over
finite traces
Star-free
regular
expressions
ltlf
FOL over
finite traces
Star-free
regular
expressions
ltlf
MSOL over
finite traces
FOL over
finite traces
Regular
expressions
Star-free
regular
expressions
pspace
complexity
Nondet.
finite-state
automata
(nfa)
(t(t|other)ú
r)(r|other)ú
)ú

ldlf
Linear Dynamic
Logic over
finite traces
ltlf
MSOL over
finite traces
FOL over
finite traces
Regular
expressions
Star-free
regular
expressions
pspace
complexity
Nondet.
finite-state
automata
(nfa)
(t(t|other)ú
r)(r|other)ú
)ú
A Key Observation
ltlf
FOL over
finite traces
Star-free
regular
expressions
ltlf
FOL over
finite traces
Star-free
regular
expressions
LTLf with regular expressions
inside <> and []
(a là PDL)

ldlf
Linear Dynamic
Logic over
finite traces
ltlf
MSOL over
finite traces
FOL over
finite traces
Regular
expressions
Star-free
regular
expressions
pspace
complexity
Nondet.
finite-state
automata
(nfa)
(t(t|other)ú
r)(r|other)ú
)ú
Back and Forth
ltlf
FOL over
finite traces
Star-free
regular
expressions
ltlf
FOL over
finite traces
Star-free
regular
expressions

ldlf
Linear Dynamic
Logic over
finite traces
ltlf
MSOL over
finite traces
FOL over
finite traces
Regular
expressions
Star-free
regular
expressions
pspace
complexity
Nondet.
finite-state
automata
(nfa)
(t(t|other)ú
r)(r|other)ú
)ú
Back and Forth
ltlf
FOL over
finite traces
Star-free
regular
expressions
ltlf
FOL over
finite traces
Star-free
regular
expressions
non-trimmed

Automata for LDLfFrom ldlf to nfa
Direct calculation of nfa corresponding to ldlf formula Ï
Algorithm
1: algorithm ldlf 2nfa()
2: input ltlf formula Ï
3: output nfa AÏ = (2P
, S, {s0}, Í, {sf })
4: s0 Ω {"Ï"} Û single initial state
5: sf Ω ÿ Û single final state
6: S Ω {s0, sf }, Í Ω ÿ
7: while (S or Í change) do
8: if (q œ S and qÕ
|=
w
("Â"œq) ”("Â", ))
9: S Ω S fi {qÕ
} Û update set of states
10: Í Ω Í fi {(q, , qÕ
)} Û update transition relation
Note
• Standard nfa.
• No detour to Büchi automata.
• Easy to code.
• Implemented!
Auxiliary rules
”("tt", ) = true
”(" ", ) = false
”("„", ) =
I
true if |= „
false if ”|= „
(„ propositional)
”("Ï1 · Ï2", ) = ”("Ï1", ) · ”("Ï2", )
”("Ï1 ‚ Ï2", ) = ”("Ï1", ) ‚ ”("Ï2", )
”("È„ÍÏ", ) =
Y
_]
_[
"Ï" if last ”œ and |= „ („ propositional)
”("Ï", ‘) if last œ and |= „
false if ”|= „
”("ÈÂ?ÍÏ", ) = ”("Â", ) · ”("Ï", )
”("Èfl1 + fl2ÍÏ", ) = ”("Èfl1ÍÏ", ) ‚ ”("Èfl2ÍÏ", )
”("Èfl1; fl2ÍÏ", ) = ”("Èfl1ÍÈfl2ÍÏ", )
”("Èflú
ÍÏ", ) =
I
”("Ï", ) if fl is test-only
”("Ï", ) ‚ ”("ÈflÍÈflúÍÏ", ) o/w
”("[„]Ï", ) =
Y
_]
_[
"Ï" if last ”œ and |= „ („ propositional)
”("Ï", ‘) if last œ and |= „ („ propositional)
true if ”|= „
”("[Â?]Ï", ) = ”("nnf (¬Â)", ) ‚ ”("Ï", )
”("[fl1 + fl2]Ï", ) = ”("[fl1]Ï", ) · ”("[fl2]Ï", )
”("[fl1; fl2]Ï", ) = ”("[fl1][fl2]Ï", )
”("[flú
]Ï", ) =
I
”("Ï", ) if fl is test-only
”("Ï", ) · ”("[fl][flú]Ï", ) o/w
Marco Montali (unibz) Monitoring Business Metaconstraints BPM 2014 22 / 26
[De Giacomo et al., BPM 2014]

Black Magic with LDLf
Runtime ldlf Monitors
Check partial trace ﬁ = e1, . . . , en against formula Ï.
From ad-hoc techniques . . .
e1 . . . en |=
C
Ï
D
RV =
Y
___]
___[
temp_true
temp_false
true
false
. . . To standard techniques
e1 . . . en |=
Y
______]
______[
Ïtemp_true
Ïtemp_false
Ïtrue
Ïfalse

Colored Automata
'
00 1
m
e
not m not e

'temp true
Colored Automata
'
'temp false 'perm false'perm true
00 1
m
e
not m not e

'temp true
Colored Automata
'
'temp false 'perm false'perm true
00 1
m
e
not m not e
00 1
m
e
not m not e

Coloring Automata
Coloring simply amounts to reachability checks!
• State permanently satisfied: it is final and cannot
reach a non-final state
• State temporarily satisfied: it is final but can reach a
non-final state
• State temporarily violated: it is non-final but can reach
a final state
• State permanently violated: it is non-final and cannot
reach a final state

Declare Enactment
Information about single constraints
• Translate each constraint into LTLf
• Compute the corresponding colored DFAs (local automata)
Hidden dependencies
• We need the global automaton for the entire model. Either:
• Take the “conjunction formula” of all constraints and get
the DFA
• Compute the intersection of the local DFAs

Local Automata
moored
under way
using engine
under way
sailing
constrained by
her draught
0
s
c
not {c,s}
true1
0 true
00 1
m
e
not m not e
s
e
not s
true00
not {s,e}
1
2
3
e
s
not e
1
2

Global Colored Automaton
By carefully intersecting local DFAs: we get a
global DFA that retains all “local colors”. 
This is… an execution engine!

An Engine for Declare
1. Compute the global, coloured DFA A
2. s = initial state of A
3. Loop
A. Block all activities that would lead to a permanent violation  
if executed in s
B. Highlight constraints that are permanently satisﬁed in s
C. Highlight constraints that are temporarily violated
• If no temporarily violated constraint: allow for completing the
process
D. Wait until an allowed activity a is executed
E. fetch s’ s.t. <s,a,s’> belongs to A
F. s = s’ 99

Implemented in ProM!
Monitoring
The same approach can be used for monitoring (just observe and
return the RV-LTL state of constraints and of the entire model)
• With LDLf, we can predicate about the truth value of constraints!
• Direct support for 
meta-constraints
• Compensation constraints
• Contrary-to-duty constraints
• Dynamic activation/ 
disablement of constraints

enactment/
monitoring
Process Mining
(re)design
models
conﬁguration/
implementation
data
diagnosis/
requirements

Declarative Process
Discovery
Event log

Declarative Process
Discovery
Event log
Declarative model  
that “best” captures the
process hidden in the log

Basic Idea of Existing
Algorithms
• Apply heuristics to guess a constraint
• Check the support of the constraint
• Check the interestingness factor of the
constraint
• Combine these two metrics to decide whether to
keep the constraint or not
• Iterate and prune

Problems
• Correctness of the overall declarative model (for
constraints with <100% support)
• Minimality of the overall declarative model (redundant
constraints)
• How to determine whether a constraint is
interesting or not
All these questions: successfully attacked with logics and
automata!

Interestingness and
Vacuity
• ababababab
• adfbcdadb
• acb
• acbaafb
• aabbabbb
⇤(a ! ⌃b)
Support: 100%
⇤(a ! ⌃b)
Support: 100%

Why is a Trace Interesting
for a Constraint?
• Because it “interacts” with the constraint
• Semantically:
• It ﬂips the RV-LTL state of the constraint
• It changes the set of allowed transitions
• Non-vacuous satisfaction = satisfaction + interestingness
• A much easier treatment than in the inﬁnite-trace case (see
works on vacuity checking in LTL)

Example
00 1
a
b
not a not b
⇤(a ! ⌃b) ⇤(a ! ⌃b)
a c b a a f b

Another Example
c a d a f
¬(⌃a ^ ⌃b)
a
b
not b
true00
not {a,b}
1
2
3
b
a
not a
1
2
c d f f

Conclusion
• BPM struggles to balance ﬂexibility and control
• Constraint-based approaches and temporal logics over ﬁnite traces
offer a declarative, solid approach
• The automata-theoretic foundations lead to a “correct by design”
computation mechanism to assist humans during the entire process
lifecycle
• A lot of open challenges!
• Mix declarative and imperative approaches
• Connection with AI tasks: synthesis (adversarial process
execution, partial observability, …)
• Redesign all reasoning tasks in the presence of data

And the Story Continues…
Object-Centric Behavioral Constraints  
(joint work with Wil van der Aalst, Guangming Li, Alessandro Artale)
OrderItem Package
Pick  
Item
Pay 
Order
Get  
Package
0..1 ** 0..1

Acknowledgments
• Wil van der Aalst
• Maja Pesic
• Federico Chesani
• Paola Mello
• Fabrizio Maggi
• Michael Westergaard
• Giuseppe De Giacomo
• Claudio di Ciccio
• Jan Mendling

Some References
Declare and its formalizations
• M. Pesic and W. van der Aalst, A Declarative Approach for Flexible Business
Processes Management, in BPM Workshops. Vol. 4103 of LNCS, pp. 169-180.
Springer, 2007.
• M. Montali, M. Pesic, W. M. P. van der Aalst, F. Chesani, P. Mello, and S. Storari,
Declarative specification and verification of service choreographies, ACM
Trans. Web, vol. 4, pp. 3:1–3:62, 2010.
• M. Montali. Specification and Verification of Declarative Open Interaction
Models: a Logic- Based Approach, vol. 56 of LNBIP. Springer, 2010.
• M. Westergaard, Better Algorithms for Analyzing and Enacting Declarative
Workflow Languages Using LTL, in BPM, vol. 6896 of LNCS, pp. 83-98. Springer,
2010.
• Giuseppe De Giacomo, Riccardo De Masellis, Marco Montali, 
Reasoning on LTL on Finite Traces: Insensitivity to Infiniteness, in AAAI, pp.
1027-1033. AAAI Press, 2014.

Some References
Declare Execution Environment
• M. Pesic, H. Schonenberg, and W. M. P. van der Aalst, DECLARE:
Full Support for Loosely-Structured Processes, in EDOC, pp.
287–300. IEEE Computer Society, 2007.
• M. Pesic, M. Schonenberg, N. Sidorova, and W. van der Aalst,
Constraint-Based Workﬂow Models: Change Made Easy, in
CoopIS, vol. 4803 of LNCS, pp. 77-94. Springer, 2007.
• M. Pesic, H. Schonenberg, and W. Aalst, The Declare Service, in
Modern Business Process Automation, Springer, 2010, pp. 327-343.
• M. Westergaard, F. M. Maggi, Declare: A Tool Suite for
Declarative Workﬂow Modeling and Enactment, BPM (Demos)
2011.

Some References
Monitoring Declare constraints
• F. M. Maggi, M. Montali, M. Westergaard, and W. M. P. van der Aalst,
Monitoring Business Constraints with Linear Temporal Logic: An
Approach Based on Colored Automata, in BPM, volume 6896 of LNCS, pp.
132-147. Springer, 2011.
• F. M. Maggi, M. Westergaard, M. Montali, W. M. P. van der Aalst, 
Runtime Veriﬁcation of LTL-Based Declarative Process Models.:
Proceedings of RV, volume 7186 of LNCS, pp. 131-146. Springer, 2011.
• M. Montali, F. M. Maggi, F. Chesani, P. Mello, W. M. P. van der Aalst, 
Monitoring business constraints with the event calculus. ACM Trans. on
Intelligent Systems and Technology 5(1): 17, 2013.
• G. De Giacomo, R. De Masellis, M. Grasso, F. M. Maggi, M. Montali,  
Monitoring Business Metaconstraints Based on LTL and LDL for Finite
Traces, in BPM, volume 8659 of LNCS, pp. 1-17. Springer, 2014.

Some References
Discovering Declare constraints
• F. Chesani, E. Lamma, P. Mello, M. Montali, F. Riguzzi, S. Storari, Exploiting Inductive Logic Programming
Techniques for Declarative Process Mining. Trans. Petri Nets and Other Models of Concurrency 2: 278-295,
2009.
• F. Maria Maggi, A. J. Mooij, W. M. P. van der Aalst, User-guided discovery of declarative process models.
In CIDM, pp. 192-199. IEEE Press, 2011.
• F. M. Maggi, R. P. J. Chandra Bose, W. M. P. van der Aalst, Efﬁcient Discovery of Understandable
Declarative Process Models from Event Logs. In CAiSE, volume 7908 of LNCS, pp. 270-285. Springer,
2012.
• F. M. Maggi, M. Dumas, L. García-Bañuelos, M. Montali, Discovering Data-Aware Declarative Process
Models from Event Logs. In BPM, volume 8094 of LNCS, pp. 81-96. Springer, 2013.
• C. Di Ciccio, M. Mecella, On the Discovery of Declarative Control Flows for Artful Processes. ACM Trans.
Management Inf. Syst. 5(4): 24:1-24:37, 2015.
• C. Di Ciccio, F. M. Maggi, M. Montali, J. Mendling, Ensuring Model Consistency in Declarative Process
Discovery. In BPM, volume 9253 of LNCS, pp. 144-159. Springer, 2015.
• C. Di Ciccio, F. M. Maggi, M. Montali, J. Mendling, Semantical Vacuity Detection in Declarative Process
Mining. In BPM, volume 9850 of LNCS, pp. 158-175. Springer, 2016.
• Claudio Di Ciccio, Fabrizio Maria Maggi, Marco Montali, Jan Mendling: 
Resolving inconsistencies and redundancies in declarative process models. Inf. Syst. 64: 425-446, 2017.

10 Years Playing with Declare and Temporal Logics on Finite Traces

Recommandé

Recommandé

Contenu connexe

Similaire à 10 Years Playing with Declare and Temporal Logics on Finite Traces

Similaire à 10 Years Playing with Declare and Temporal Logics on Finite Traces (20)

Plus de Faculty of Computer Science - Free University of Bozen-Bolzano

Plus de Faculty of Computer Science - Free University of Bozen-Bolzano (20)

Dernier

Dernier (20)

10 Years Playing with Declare and Temporal Logics on Finite Traces