org.processmining.hybrid.execsemantics.experimental.impl.TS

Class ExpExecSemanticsConjunctiveTransitionSystemImpl

java.lang.Object

org.processmining.hybrid.execsemantics.experimental.impl.TS.ExpExecSemanticsConjunctiveTransitionSystemImpl

public class ExpExecSemanticsConjunctiveTransitionSystemImpl
extends java.lang.Object

Author:

D.M.M. Schunselaar TODO: no support yet for the independence relation The independence relation might be more challenging since assume the following model: B chain resp C, C chain resp D, etc., Y chain resp. Z, and Z not chain succession A. Now assume A is a subprocess (Declare). If A is running, and we execute B, then we cannot terminate A after Z. However, it might be that A is in an accepting state and only after Z we realise we had to terminate. In principle, one could argue that A terminated earlier. As long as the constraints connected to A did not require A to explicitly terminate things should be fine. TODO: say we have Resp(B, A), Resp(B, C), not-succ(A, C), then after executing B, we can only do C and then A (else we reach a deadlock), how to encode this? This has not been taken into account yet (though under the fitness 1 assumption, there will be no problems, just a lower precision score since we allow for more behaviour). Is this actually supported in the Petri net? (soundness), can we somehow pose extra requirements on the Declare model/TS to mitigate this risk? This would somehow imply conditional constraints, also, since B is not constraint, we can still do B after A. So either the constraints are somehow transitively closed, or we need quite some machinery to verify some actions are actually possible from a given state by checking that the final state can still be reached (would also work nicely for alignments). We could store for every state tempDisabled and permDisabled (we had the idea earlier I think) and then verify it against other activities that need to happen to reach an accepting state. We do have a disjunction/conjunction of activities per branched constraint. How does it work if we need to execute other activities before we can execute the activity we want (chain succession constraints) and the other activities are disabled? This should follow from one of the other constraints. So we should take into account which activities need to be executed to enable an activity again and none/not all should be disabled.

Field Summary

Fields

Modifier and Type	Field and Description
protected HybridContext	context
protected java.util.List<java.lang.Object>	currentState
protected java.util.List<java.util.Map<org.processmining.models.graphbased.directed.transitionsystem.State,java.util.Collection<java.lang.String>>>	disabledActions
protected java.lang.String	executingTransition
protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.AcceptStateSet>	finalStates
protected java.util.List<java.lang.Object>	initialState
protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.StartStateSet>	initialStates
protected java.util.List<HybridContext>	localContext
protected java.util.List<java.util.Set<java.lang.String>>	omegaMapping
protected java.util.List<java.lang.Object>	previousCurrentState
protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.TransitionSystem>	trans

Constructor Summary

Constructors

Constructor and Description
ExpExecSemanticsConjunctiveTransitionSystemImpl(java.util.List<java.lang.Object[]> transitionSystems, HybridContext hybridContext)

Method Summary

Modifier and Type	Method and Description
boolean	canTerminate(java.util.Collection<java.lang.String> canTerminate)
void	endTransition(java.lang.String t)
void	executeTransition(java.lang.String t)
java.util.Collection<java.lang.String>	getNamesOfEnabledTransitions(java.util.Collection<java.lang.String> canTerminate) TODO: Not yet checked the transitive closure (transitive closure is something specific for the Precision computation, we can maybe split this)
void	initialise()
boolean	isAccepting()
void	startTransition(java.lang.String t)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

trans

protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.TransitionSystem> trans

initialStates

protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.StartStateSet> initialStates

finalStates

protected java.util.List<org.processmining.models.graphbased.directed.transitionsystem.AcceptStateSet> finalStates

localContext

protected java.util.List<HybridContext> localContext

omegaMapping

protected java.util.List<java.util.Set<java.lang.String>> omegaMapping

disabledActions

protected java.util.List<java.util.Map<org.processmining.models.graphbased.directed.transitionsystem.State,java.util.Collection<java.lang.String>>> disabledActions

initialState

protected java.util.List<java.lang.Object> initialState

currentState

protected java.util.List<java.lang.Object> currentState

previousCurrentState

protected java.util.List<java.lang.Object> previousCurrentState

executingTransition

protected java.lang.String executingTransition

context

protected HybridContext context

Constructor Detail

ExpExecSemanticsConjunctiveTransitionSystemImpl

public ExpExecSemanticsConjunctiveTransitionSystemImpl(java.util.List<java.lang.Object[]> transitionSystems,
                                                       HybridContext hybridContext)

Method Detail

initialise

public void initialise()

isAccepting

public boolean isAccepting()

canTerminate

public boolean canTerminate(java.util.Collection<java.lang.String> canTerminate)

Parameters:

canTerminate: - These are the transition corresponding to subprocesses that can terminate

Returns:

getNamesOfEnabledTransitions

public java.util.Collection<java.lang.String> getNamesOfEnabledTransitions(java.util.Collection<java.lang.String> canTerminate)

TODO: Not yet checked the transitive closure (transitive closure is something specific for the Precision computation, we can maybe split this)

Returns:

executeTransition

public void executeTransition(java.lang.String t)

startTransition

public void startTransition(java.lang.String t)

endTransition

public void endTransition(java.lang.String t)