pm4py.algo.discovery.inductive.cuts package#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

Submodules#

pm4py.algo.discovery.inductive.cuts.abc module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.abc.Cut[source]#

Bases: ABC, Generic[T]

abstract classmethod operator(parameters: Optional[Dict[str, Any]] = None) ProcessTree[source]#
abstract classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#
classmethod apply(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[Tuple[ProcessTree, List[T]]][source]#
abstract classmethod project(obj: T, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[T][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

pm4py.algo.discovery.inductive.cuts.concurrency module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.concurrency.ConcurrencyCut[source]#

Bases: Cut[T], ABC, Generic[T]

classmethod operator(parameters: Optional[Dict[str, Any]] = None) ProcessTree[source]#
classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#
class pm4py.algo.discovery.inductive.cuts.concurrency.ConcurrencyCutUVCL[source]#

Bases: ConcurrencyCut[IMDataStructureUVCL]

classmethod project(obj: IMDataStructureUVCL, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureUVCL][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

class pm4py.algo.discovery.inductive.cuts.concurrency.ConcurrencyCutDFG[source]#

Bases: ConcurrencyCut[IMDataStructureDFG]

classmethod project(obj: IMDataStructureDFG, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureDFG][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

pm4py.algo.discovery.inductive.cuts.factory module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.factory.Parameters(value)[source]#

Bases: Enum

An enumeration.

DISABLE_STRICT_SEQUENCE_CUT = 'disable_strict_sequence_cut'#
class pm4py.algo.discovery.inductive.cuts.factory.CutFactory[source]#

Bases: object

classmethod get_cuts(obj: T, inst: IMInstance, parameters: Optional[Dict[str, Any]] = None) List[S][source]#
classmethod find_cut(obj: IMDataStructure, inst: IMInstance, parameters: Optional[Dict[str, Any]] = None) Optional[Tuple[ProcessTree, List[T]]][source]#

pm4py.algo.discovery.inductive.cuts.loop module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.loop.LoopCut[source]#

Bases: Cut[T], ABC, Generic[T]

classmethod operator(parameters: Optional[Dict[str, Any]] = None) ProcessTree[source]#
classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method finds a loop cut in the dfg. Implementation follows function LoopCut on page 190 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4)

Basic Steps: 1. merge all start and end activities in one group (‘do’ group) 2. remove start/end activities from the dfg 3. detect connected components in (undirected representative) of the reduced graph 4. check if each component meets the start/end criteria of the loop cut definition (merge with the ‘do’ group if not) 5. return the cut if at least two groups remain

class pm4py.algo.discovery.inductive.cuts.loop.LoopCutUVCL[source]#

Bases: LoopCut[IMDataStructureUVCL]

classmethod project(obj: IMDataStructureUVCL, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureUVCL][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

class pm4py.algo.discovery.inductive.cuts.loop.LoopCutDFG[source]#

Bases: LoopCut[IMDataStructureDFG]

classmethod project(obj: IMDataStructureUVCL, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureDFG][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

pm4py.algo.discovery.inductive.cuts.sequence module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.sequence.SequenceCut[source]#

Bases: Cut[T], ABC, Generic[T]

classmethod operator(parameters: Optional[Dict[str, Any]] = None) ProcessTree[source]#
classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method finds a sequence cut in the dfg. Implementation follows function sequence on page 188 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4)

Basic Steps: 1. create a group per activity 2. merge pairwise reachable nodes (based on transitive relations) 3. merge pairwise unreachable nodes (based on transitive relations) 4. sort the groups based on their reachability

class pm4py.algo.discovery.inductive.cuts.sequence.StrictSequenceCut[source]#

Bases: SequenceCut[T], ABC, Generic[T]

classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method implements the strict sequence cut as defined on page 233 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4) The function merges groups that together can be skipped.

class pm4py.algo.discovery.inductive.cuts.sequence.SequenceCutUVCL[source]#

Bases: SequenceCut[IMDataStructureUVCL]

classmethod project(obj: IMDataStructureUVCL, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureUVCL][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

class pm4py.algo.discovery.inductive.cuts.sequence.StrictSequenceCutUVCL[source]#

Bases: StrictSequenceCut[IMDataStructureUVCL], SequenceCutUVCL

classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method implements the strict sequence cut as defined on page 233 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4) The function merges groups that together can be skipped.

class pm4py.algo.discovery.inductive.cuts.sequence.SequenceCutDFG[source]#

Bases: SequenceCut[IMDataStructureDFG]

classmethod project(obj: IMDataStructureDFG, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureDFG][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

class pm4py.algo.discovery.inductive.cuts.sequence.StrictSequenceCutDFG[source]#

Bases: StrictSequenceCut[IMDataStructureDFG], SequenceCutDFG

classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method implements the strict sequence cut as defined on page 233 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4) The function merges groups that together can be skipped.

pm4py.algo.discovery.inductive.cuts.utils module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

pm4py.algo.discovery.inductive.cuts.utils.merge_groups_based_on_activities(a, b, groups)[source]#
pm4py.algo.discovery.inductive.cuts.utils.merge_lists_based_on_activities(a, b, groups)[source]#

pm4py.algo.discovery.inductive.cuts.xor module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.discovery.inductive.cuts.xor.ExclusiveChoiceCut[source]#

Bases: Cut[T], ABC, Generic[T]

classmethod operator(parameters: Optional[Dict[str, Any]] = None) ProcessTree[source]#
classmethod holds(obj: T, parameters: Optional[Dict[str, Any]] = None) Optional[List[Collection[Any]]][source]#

This method finds a xor cut in the dfg. Implementation follows function XorCut on page 188 of “Robust Process Mining with Guarantees” by Sander J.J. Leemans (ISBN: 978-90-386-4257-4)

Basic Steps: 1.) the dfg is transformed to its undirected equivalent. 2.) we detect the connected components in the graph. 3.) if there are more than one connected components, the cut exists and is non-minimal.

class pm4py.algo.discovery.inductive.cuts.xor.ExclusiveChoiceCutUVCL[source]#

Bases: ExclusiveChoiceCut[IMDataStructureUVCL]

classmethod project(obj: IMDataStructureUVCL, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureUVCL][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object

class pm4py.algo.discovery.inductive.cuts.xor.ExclusiveChoiceCutDFG[source]#

Bases: ExclusiveChoiceCut[IMDataStructureDFG]

classmethod project(obj: IMDataStructureDFG, groups: List[Collection[Any]], parameters: Optional[Dict[str, Any]] = None) List[IMDataStructureDFG][source]#

Projection of the given data object (Generic type T). Returns a corresponding process tree and the projected sub logs according to the identified groups. A precondition of the project function is that it holds on the object for the given Object