Ebi - a stochastic process mining tool

Ebi is a stochastic process mining software suite, maintained by the BPM group of RWTH University, Aachen, Germany. It contains several algorithms and techniques that perform analyses on event logs and process models.
Ebi can be used as a command-line utility, in ProM, or as a Rust library.

Ebi as a command-line interface tool

Download

Ready-to-use up-to-date binaries are available for Windows and Linux.

Ebi runs on Mac too; please see the manual on how to compile it in 5 easy steps.

Usage

Installation is not necessary: simply call the executable from a command line. Ebi does not use network access.
In Linux, you may need to give the executable execution permission.

An overview of the functions of Ebi and more information on its algorithms can be found in the manual.
Alternatively, you can execute Ebi with `--help' for an overview of commands.

Ebi as a Python library

Ebi is available as a Python library, closely integrated with PM4PY. To install the Ebi Python library, install it using Pip:


	pip install ebi-pm

Then, one can use it as follows:


	import pm4py
        import ebi-pm
# Load a log using PM4Py log = pm4py.read_xes("myLog.xes", return_legacy_log_object=True) # Load a model as a string with open('mymodel.slpn', 'r') as file: model = file.read() # Call the Ebi function result = ebi.conformance_earth_movers_sample( log, model, 1000 ) print(result)

An overview of the functions of Ebi available to Python and more information on its algorithms can be found in the manual.

Ebi in ProM

Ebi is also available in ProM. In the ProM Package Manager, install Ebi. Then, several Ebi commands can be used like any other ProM plug-in. As Ebi is extremely flexible in its inputs and outputs, please ensure you choose the correct input and output plug-in (there are many).

The manual contains an overview of Ebi commands that are available in ProM.

Ebi as a Rust library

Ebi is also available as a Rust library. More information can be found on crates.io.

Source

Ebi's source code is available from Github.

Ebi - a stochastic process mining tool
Ebi analyse all-traces

Ebi analyse all-traces

Short alias: Ebi ana all.
List all traces of a stohastic model. Models containing loops and unbounded models are not supported and the computation will run forever.
Parameters:
<FILE> Any object with deterministic stochastic semantics.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_all_traces.
Ebi analyse completeness

Ebi analyse completeness

Short alias: Ebi ana comp.
Estimate the completeness of an event log using species discovery. More information is available in the PDF manual.
Parameters:
<FILE> An event log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_completeness.
Ebi analyse coverage

Ebi analyse coverage

Short alias: Ebi ana cov.
Find the most-likely traces that together cover the given minimum probability. Will return a finite stochastic language with the extracted traces. The computation may not terminate if the model has non-decreasing livelocks, or if the model is unbounded and this unboundedness can be triggered using silent transitions, or if the model has livelocks.
Parameters:
<FILE> Any object with deterministic stochastic semantics.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MINIMUM_COVERAGE> The minimum probability that a trace should have to be included.
Accepted values:
  • fraction between 0 and 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_coverage.
Ebi analyse directly-follows-edge-difference

Ebi analyse directly-follows-edge-difference

Short alias: Ebi ana dfgedi.
The number of edges that differ between two directly follows graphs.
Parameters:
<DFG_1> A directly follows graph.
Accepted values:
  • directly follows graph (.dfg)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<DFG_2> A directly follows graph.
Accepted values:
  • directly follows graph (.dfg)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_directly_follows_edge_difference.
Ebi analyse medoid

Ebi analyse medoid

Short alias: Ebi ana med.
Find the traces with the lowest average normalised Levenshtein distance to the other traces. If there are more than one such trace, an arbitrary one is returned.
Parameters:
<FILE> Any object with a finite stochastic language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> The number of traces that should be extracted.
Accepted values:
  • integer
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_medoid.
Ebi analyse minimum-probability-traces

Ebi analyse minimum-probability-traces

Short alias: Ebi ana minprob.
Find all traces that have a given minimum probability. Will return a finate stochastic language with the extracted traces. Will return an error if there are no such traces. The computation may not terminate if the model is unbounded and this unboundedness can be triggered using silent transitions.
Parameters:
<FILE> Any object with deterministic stochastic semantics.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MINIMUM_PROBABILITY> The minimum probability that a trace should have to be included.
Accepted values:
  • fraction between 0 and 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_minimum_probability_traces.
Ebi analyse mode

Ebi analyse mode

Find the trace with the highest probability. If there is more than one trace with the highest probability, an arbitrary choice is made which one to return. The computation may run forever if the model is unbounded. Equivalent to `Ebi evaluate mostlikely 1`. Computation is more efficient for a model with a finite stochastic language.
Parameters:
<FILE> Any object with deterministic stochastic semantics.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_mode.
Ebi analyse most-likely-traces

Ebi analyse most-likely-traces

Short alias: Ebi ana mostlikely.
Find the given number of traces with the highest probabilities. If there are more than one trace with the same probability, an arbitrary choice is made which one to return. The computation may run forever if the model is unbounded. Computation is more efficient for an object with a finite stochastic language.
Parameters:
<FILE> Any object with deterministic stochastic semantics.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> The number of traces that should be extracted.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_most_likely_traces.
Ebi analyse variety

Ebi analyse variety

Short alias: Ebi ana var.
Compute the variety of a stochastic language. That is, the average distance between two arbitrary traces in the language.
Parameters:
<FILE> An event log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_variety.
Ebi analyse-non-stochastic activities

Ebi analyse-non-stochastic activities

Short alias: Ebi anans act.
Shows the activities that are declared in the object.
Parameters:
<FILE> Any object with activities.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • language of alignments (.ali)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic language of alignments (.sali)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_activities.
Ebi analyse-non-stochastic any-traces

Ebi analyse-non-stochastic any-traces

Short alias: Ebi anans at.
Compute whether the model has any traces. Reasons for a model not to have any traces could be if the initial state is part of a livelock, or if there is no initial state. 'true' means that the model has traces, 'false' means that the model has no traces. The computation may not terminate if the model is unbounded.
Parameters:
<MODEL> The model.
Accepted values:
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_any_traces.
Ebi analyse-non-stochastic bounded

Ebi analyse-non-stochastic bounded

Short alias: Ebi anans bnd.
Compute whether the model has a bounded state space. For Petri nets, a coverability graph is computed~\cite{esparza2019petri}. For other types of models, `true' is returned.
Parameters:
<MODEL> The model.
Accepted values:
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_bounded.
Ebi analyse-non-stochastic cluster

Ebi analyse-non-stochastic cluster

Short alias: Ebi anans clus.
Apply k-medoid clustering: group the traces into a given number of clusters, such that the average distance of each trace to its closest medoid is minimal. The computation is random and does not take into account how often each trace occurs. More information is available in the PDF manual.
Parameters:
<LANGUAGE> The finite stochastic language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_CLUSTERS> The number of clusters.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_cluster.
Ebi analyse-non-stochastic executions

Ebi analyse-non-stochastic executions

Short alias: Ebi anans exe.
Compute executions. NB 1: the model must be able to terminate and its states must be bounded. NB 2: the search performed is not optimised. For Petri nets, the ProM implementation may be more efficient.
Parameters:
<LOG> The event log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)*
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MODEL> The model.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The executions (.exs) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of executions (.exs).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_executions.
Ebi analyse-non-stochastic infinitely-many-traces

Ebi analyse-non-stochastic infinitely-many-traces

Short alias: Ebi anans inft.
Compute whether the model has infinitely many traces. The computation may not terminate if the model is unbounded.
Parameters:
<MODEL> The model.
Accepted values:
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_infinitely_many_traces.
Ebi analyse-non-stochastic medoid

Ebi analyse-non-stochastic medoid

Short alias: Ebi anans med.
Find the traces with the lowest average normalised Levenshtein distance to the other traces; ties are resolved arbritrarily. The computation is random and does not take into account how often each trace occurs.
Parameters:
<FILE> The finite stochastic language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> The number of traces that should be extracted.
Accepted values:
  • integer
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_medoid.
Ebi association all-trace-attributes

Ebi association all-trace-attributes

Short alias: Ebi asso atts.
Compute the association between the process and trace attributes. More information is available in the PDF manual.
Parameters:
<FILE> The event log for which association is to be computed.
Accepted values:
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<SAMPLES> The number of samples taken.
Accepted values:
  • integer above 1
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function association_all_trace_attributes.
Ebi association trace-attribute

Ebi association trace-attribute

Short alias: Ebi asso att.
Compute the association between the process and a trace attribute. More information is available in the PDF manual.
Parameters:
<FILE> The event log for which association is to be computed.
Accepted values:
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<ATTRIBUTE> The trace attribute for which association is to be computed the trace attributes of a log can be found using ebi info.
Accepted values:
  • text
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<SAMPLES> The number of samples.
Accepted values:
  • integer above 1
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The root file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of containsroot (.croot).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function association_trace_attribute.
Ebi conformance chi-squared

Ebi conformance chi-squared

Short alias: Ebi conf cssc.
Compute chi-square stochastic conformance. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A queriable stochastic language model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_chi_squared.
Ebi conformance chi-squared-sample

Ebi conformance chi-squared-sample

Short alias: Ebi conf cssc-sample.
Compute chi-square stochastic conformance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `cssc`. More information is available in the PDF manual.
Parameters:
<FILE_1> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> Number of traces to sample.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_chi_squared_sample.
Ebi conformance earth-movers

Ebi conformance earth-movers

Short alias: Ebi conf emsc.
Compute Earth mover's stochastic conformance, which is 1 - the Wasserstein distance. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language to compare may be partially ordered.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A finite stochastic language to compare may be partially ordered.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_earth_movers.
Ebi conformance earth-movers-sample

Ebi conformance earth-movers-sample

Short alias: Ebi conf emsc-sample.
Compute Earth mover's stochastic conformance, which is 1 - the Wasserstein distance, where one or both of the inputs needs to be sampled. If both inputs are logs or finite stochastic languages, then use `emsc`. More information is available in the PDF manual.
Parameters:
<FILE_1> A stochastic language log or model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A stochastic language log or model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> Number of traces to sample.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_earth_movers_sample.
Ebi conformance entropic-relevance

Ebi conformance entropic-relevance

Short alias: Ebi conf er.
Compute entropic relevance (uniform). More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A queriable stochastic language model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The logarithm file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of logdiv (.logdiv).
This command is available in the ebi-pm Python package using the function conformance_entropic_relevance.
Ebi conformance hellinger

Ebi conformance hellinger

Short alias: Ebi conf hsc.
Compute Hellinger stochastic conformance, which is 1 - the Hellinger distance. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A queriable stochastic language model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_hellinger.
Ebi conformance hellinger-sample

Ebi conformance hellinger-sample

Short alias: Ebi conf hsc-sample.
Compute Hellinger stochastic conformance, which is 1 - the Hellinger distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `hsc`. More information is available in the PDF manual.
Parameters:
<FILE_1> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> Number of traces to sample.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_hellinger_sample.
Ebi conformance jensen-shannon

Ebi conformance jensen-shannon

Short alias: Ebi conf jssc.
Compute Jensen-Shannon stochastic conformance, which is 1 - the Jensen-Shannon distance. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A queriable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The rootlog file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of rootlogdiv (.rldiv).
This command is available in the ebi-pm Python package using the function conformance_jensen_shannon.
Ebi conformance jensen-shannon-sample

Ebi conformance jensen-shannon-sample

Short alias: Ebi conf jssc-sample.
Compute Jensen-Shannon stochastic conformance, which is 1 - the Jensen-Shannon distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `jssc`. More information is available in the PDF manual.
Parameters:
<FILE_1> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> Number of traces to sample.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The rootlog file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of rootlogdiv (.rldiv).
This command is available in the ebi-pm Python package using the function conformance_jensen_shannon_sample.
Ebi conformance markovian

Ebi conformance markovian

Short alias: Ebi conf ma.
Compute the conformance between two stochastic languages using a stochastic Markovian abstraction, which represents languages based on the expected frequency of subtraces to handle partially matching traces. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language or a stochastic labelled petri net log to compare an s l p n must be livelock free and bounded.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A finite stochastic language or a stochastic labelled petri net model to compare an s l p n must be livelock free and bounded.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<K_ORDER> The order of the markovian abstraction length of subtraces.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MEASURE> The stochastic conformance measure to be applied to the abstractions.
Accepted values:
  • `cssc`
  • `hsc`
  • `uemsc`
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_markovian.
Ebi conformance unit-earth-movers

Ebi conformance unit-earth-movers

Short alias: Ebi conf uemsc.
Compute unit-earth movers' stochastic conformance, which is 1 - the total variation distance. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A queriable stochastic language model to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_unit_earth_movers.
Ebi conformance unit-earth-movers-sample

Ebi conformance unit-earth-movers-sample

Short alias: Ebi conf uemsc-sample.
Compute unit-earth movers' stochastic conformance, which is 1 - the total variation distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `uemsc`. More information is available in the PDF manual.
Parameters:
<FILE_1> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A sampleable stochastic language to compare.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> Number of traces to sample.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
This command is available in the ebi-pm Python package using the function conformance_unit_earth_movers_sample.
Ebi conformance-non-stochastic alignments

Ebi conformance-non-stochastic alignments

Short alias: Ebi confns ali.
Compute alignments. The model must be able to terminate and its states must be bounded. The search performed is not optimised. For Petri nets, the ProM implementation may be more efficient. More information is available in the PDF manual.
Parameters:
<FILE_1> The finite stochastic language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> The model.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • ali (language of alignments)
  • sali (stochastic language of alignments)
Mandatory: no. If no value is provided, the default of sali (stochastic language of alignments) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • language of alignments (.ali)
  • stochastic language of alignments (.sali)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sali stochastic language of alignments (.sali).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_alignments.
Ebi conformance-non-stochastic escaping-edges-precision

Ebi conformance-non-stochastic escaping-edges-precision

Short alias: Ebi confns eep.
Computes a prefix automaton of the alignments, where the states represent model states that have been visited by the alignments. The states are weighed by the probability of traces visiting them. The precision is then the sum of the number of taken edges out of each state multiplied by the weight of the state, divided by the sum of the number of outgoing edges multiplied by the weight of the states. More information is available in the PDF manual.
Parameters:
<ALIGNMENTS> The alignments.
Accepted values:
  • stochastic language of alignments (.sali)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MODEL> The model from which the alignments were computed.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_escaping_edges_precision.
Ebi conformance-non-stochastic set-alignments

Ebi conformance-non-stochastic set-alignments

Short alias: Ebi confns setali.
Compute a non-weighted set of alignments. The model must be able to terminate and its states must be bounded. The search performed is not optimised. For Petri nets, the ProM implementation may be more efficient. More information is available in the PDF manual.
Parameters:
<FILE_1> The finite language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> The model.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The language of alignments (.ali) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of language of alignments (.ali).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_set_alignments.
Ebi conformance-non-stochastic trace-fitness

Ebi conformance-non-stochastic trace-fitness

Short alias: Ebi confns tfit.
Compute the trace-fitness of a stochastic language of alignments: the number of synchronous moves divided by the total number of moves, both without silent moves.
Parameters:
<ALIGNMENTS> The stochastic language of alignments.
Accepted values:
  • stochastic language of alignments (.sali)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_trace_fitness.
Ebi convert business-process-model-and-notation

Ebi convert business-process-model-and-notation

Short alias: Ebi conv bpmn.
Convert an object to a Business Process Model and Notation.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Petri net markup language (.pnml)*
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)*
  • directly follows graph (.dfg)*
  • directly follows model (.dfm)*
  • labelled Petri net (.lpn)*
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)*
  • stochastic directly follows model (.sdfm)*
  • stochastic labelled Petri net (.slpn)*
  • stochastic non-deterministic finite automaton (.snfa)*
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_business_process_model_and_notation.
Ebi convert finite-language

Ebi convert finite-language

Short alias: Ebi conv lang.
Convert an object to a finite language.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_finite_language.
Ebi convert finite-stochastic-language

Ebi convert finite-stochastic-language

Short alias: Ebi conv slang.
Convert an object to a finite stochastic language.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_finite_stochastic_language.
Ebi convert labelled-petri-net

Ebi convert labelled-petri-net

Short alias: Ebi conv lpn.
Convert an object to a labelled Petri net.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Petri net markup language (.pnml)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of lpn (labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lpn labelled Petri net (.lpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_labelled_petri_net.
Ebi convert log

Ebi convert log

Convert an object to an event log, considering only its traces.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • csv (comma-separated values)
  • xes.gz (compressed event log)
  • dfa (deterministic finite automaton)
  • xes (extensible event stream)
  • lang (finite language)
  • slang (finite stochastic language)
  • pel (Python event log)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • Python event log (.pel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_log.
Ebi convert stochastic-deterministic-finite-automaton

Ebi convert stochastic-deterministic-finite-automaton

Short alias: Ebi conv sdfa.
Convert an object to a stochastic deterministic finite automaton.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • sdfa (stochastic deterministic finite automaton)
  • slpn (stochastic labelled Petri net)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of sdfa (stochastic deterministic finite automaton) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sdfa stochastic deterministic finite automaton (.sdfa).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_stochastic_deterministic_finite_automaton.
Ebi convert stochastic-labelled-petri-net

Ebi convert stochastic-labelled-petri-net

Short alias: Ebi conv slpn.
Convert an object to a stochastic labelled Petri net.
Parameters:
<FILE> Any file supported by ebi that can be converted.
Accepted values:
  • directly follows graph (.dfg)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_stochastic_labelled_petri_net.
Ebi convert stochastic-nondeterministic-finite-automaton

Ebi convert stochastic-nondeterministic-finite-automaton

Short alias: Ebi conv snfa.
Convert an object to a stochastic nondeterministic finite automaton.
Parameters:
<FILE> Any file supported by ebi that can be converted an s l p n must be livelock free and bounded.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of snfa (stochastic non-deterministic finite automaton) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is snfa stochastic non-deterministic finite automaton (.snfa).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function convert_stochastic_nondeterministic_finite_automaton.
Ebi discover alignments stochastic-business-process-model-and-notation

Ebi discover alignments stochastic-business-process-model-and-notation

Short alias: Ebi disc ali sbpmn.
Give each transition a weight that matches the aligned occurrences of its label. The model must be livelock-free. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to get the occurrences from.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A business process model and notation with the control flow.
Accepted values:
  • Petri net markup language (.pnml)*
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)*
  • directly follows graph (.dfg)*
  • directly follows model (.dfm)*
  • labelled Petri net (.lpn)*
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)*
  • stochastic directly follows model (.sdfm)*
  • stochastic labelled Petri net (.slpn)*
  • stochastic non-deterministic finite automaton (.snfa)*
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_alignments_stochastic_business_process_model_and_notation.
Ebi discover alignments stochastic-labelled-Petri-nets

Ebi discover alignments stochastic-labelled-Petri-nets

Short alias: Ebi disc ali slpn.
Give each transition a weight that matches the aligned occurrences of its label. The model must be livelock-free. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to get the occurrences from.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A labelled petri net with the control flow.
Accepted values:
  • Petri net markup language (.pnml)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_alignments_stochastic_labelled_petri_nets.
Ebi discover directly-follows-graph

Ebi discover directly-follows-graph

Short alias: Ebi disc dfg.
Discover a directly follows graph. More information is available in the PDF manual.
Parameters:
<LANG> A finite stochastic language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<MIN_FITNESS> The minimum fraction of traces that should fit the resulting model.
Accepted values:
  • fraction between 0 and 1
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • dfg (directly follows graph)
  • dfm (directly follows model)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • sdfm (stochastic directly follows model)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of dfg (directly follows graph) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfg directly follows graph (.dfg).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_directly_follows_graph.
Ebi discover occurrence stochastic-business-process-model-and-notation

Ebi discover occurrence stochastic-business-process-model-and-notation

Short alias: Ebi disc occ sbpmn.
Give each sequence flow to a task a weight that matches the occurrences of its label; other sequence flows get a weight of 1. More information is available in the PDF manual.
Parameters:
<LANG> A finite stochastic language log to get the occurrences from.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<BPMN> A business process model and notation model with the control flow.
Accepted values:
  • Petri net markup language (.pnml)*
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)*
  • directly follows graph (.dfg)*
  • directly follows model (.dfm)*
  • labelled Petri net (.lpn)*
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)*
  • stochastic directly follows model (.sdfm)*
  • stochastic labelled Petri net (.slpn)*
  • stochastic non-deterministic finite automaton (.snfa)*
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_business_process_model_and_notation.
Ebi discover occurrence stochastic-labelled-Petri-net

Ebi discover occurrence stochastic-labelled-Petri-net

Short alias: Ebi disc occ slpn.
Give each transition a weight that matches the occurrences of its label; silent transitions get a weight of 1. More information is available in the PDF manual.
Parameters:
<FILE_1> A finite stochastic language log to get the occurrences from.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> A labelled petri net with the control flow.
Accepted values:
  • Petri net markup language (.pnml)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_labelled_petri_net.
Ebi discover occurrence stochastic-process-tree

Ebi discover occurrence stochastic-process-tree

Short alias: Ebi disc occ sptree.
Give each leaf a weight that matches the occurrences of its label; silent leaves get a weight of 1. More information is available in the PDF manual.
Parameters:
<LANG> A finite stochastic language log to get the occurrences from.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<TREE> A process tree with the control flow.
Accepted values:
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • ptree (process tree)
  • ptml (process tree markup language)
  • svg (scalable vector graphics)
  • snfa (stochastic non-deterministic finite automaton)
  • sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_process_tree.
Ebi discover random stochastic-business-process-model-and-notation

Ebi discover random stochastic-business-process-model-and-notation

Short alias: Ebi disc rnd sbpmn.
Give each sequence flow a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
<BPMN> A business process model and notation model with the control flow.
Accepted values:
  • Petri net markup language (.pnml)*
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)*
  • directly follows graph (.dfg)*
  • directly follows model (.dfm)*
  • labelled Petri net (.lpn)*
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)*
  • stochastic directly follows model (.sdfm)*
  • stochastic labelled Petri net (.slpn)*
  • stochastic non-deterministic finite automaton (.snfa)*
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_random_stochastic_business_process_model_and_notation.
Ebi discover random stochastic-labelled-Petri-net

Ebi discover random stochastic-labelled-Petri-net

Short alias: Ebi disc rnd slpn.
Give each transition a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
<LPN> A labelled petri net.
Accepted values:
  • Petri net markup language (.pnml)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_random_stochastic_labelled_petri_net.
Ebi discover random stochastic-process-tree

Ebi discover random stochastic-process-tree

Short alias: Ebi disc rnd sptree.
Give each leaf a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
<TREE> A process tree.
Accepted values:
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • ptree (process tree)
  • ptml (process tree markup language)
  • svg (scalable vector graphics)
  • snfa (stochastic non-deterministic finite automaton)
  • sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_random_stochastic_process_tree.
Ebi discover uniform stochastic-business-process-model-and-notation

Ebi discover uniform stochastic-business-process-model-and-notation

Short alias: Ebi disc uni sbpmn.
Give each sequence flow a weight of 1.
Parameters:
<BPMN> A business process model and notation model.
Accepted values:
  • Petri net markup language (.pnml)*
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)*
  • directly follows graph (.dfg)*
  • directly follows model (.dfm)*
  • labelled Petri net (.lpn)*
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)*
  • stochastic directly follows model (.sdfm)*
  • stochastic labelled Petri net (.slpn)*
  • stochastic non-deterministic finite automaton (.snfa)*
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_business_process_model_and_notation.
Ebi discover uniform stochastic-labelled-Petri-net

Ebi discover uniform stochastic-labelled-Petri-net

Short alias: Ebi disc uni slpn.
Give each transition a weight of 1.
Parameters:
<LPN> A labelled petri net.
Accepted values:
  • Petri net markup language (.pnml)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
  • slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
  • stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_labelled_petri_net.
Ebi discover uniform stochastic-process-tree

Ebi discover uniform stochastic-process-tree

Short alias: Ebi disc uni sptree.
Give each leaf a weight of 1 in a process tree.
Parameters:
<TREE> A process tree.
Accepted values:
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • ptree (process tree)
  • ptml (process tree markup language)
  • svg (scalable vector graphics)
  • snfa (stochastic non-deterministic finite automaton)
  • sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_process_tree.
Ebi discover-non-stochastic flower deterministic-finite-automaton

Ebi discover-non-stochastic flower deterministic-finite-automaton

Short alias: Ebi dins flw dfa.
Discover a DFA that supports any trace with the activities of the log.
Parameters:
<FILE> A file with activities.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • language of alignments (.ali)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic language of alignments (.sali)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of dfa (deterministic finite automaton) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfa deterministic finite automaton (.dfa).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_non_stochastic_flower_deterministic_finite_automaton.
Ebi discover-non-stochastic flower process-tree

Ebi discover-non-stochastic flower process-tree

Short alias: Ebi dins flw ptree.
Discover a process tree that supports any trace with the activities of the log.
Parameters:
<FILE> A file with activities.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • language of alignments (.ali)
  • object-centric event log (.ocel)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic language of alignments (.sali)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • ptree (process tree)
  • ptml (process tree markup language)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of ptree (process tree) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is ptree process tree (.ptree).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_non_stochastic_flower_process_tree.
Ebi discover-non-stochastic prefix-tree deterministic-finite-automaton

Ebi discover-non-stochastic prefix-tree deterministic-finite-automaton

Short alias: Ebi dins pfxt dfa.
Discover a DFA that is a prefix tree of the log.
Parameters:
<LANG> A finite language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • dfa (deterministic finite automaton)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of dfa (deterministic finite automaton) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfa deterministic finite automaton (.dfa).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_non_stochastic_prefix_tree_deterministic_finite_automaton.
Ebi discover-non-stochastic prefix-tree process-tree

Ebi discover-non-stochastic prefix-tree process-tree

Short alias: Ebi dins pfxt ptree.
Discover a process tree that is a prefix tree of the log.
Parameters:
<LANG> A finite language.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • bpmn (business process model and notation)
  • lpn (labelled Petri net)
  • lola (LoLa Petri net)
  • pnml (Petri net markup language)
  • pdf (portable document format)
  • png (portable network graphics)
  • ptree (process tree)
  • ptml (process tree markup language)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of ptree (process tree) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • business process model and notation (.bpmn)
  • labelled Petri net (.lpn)
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is ptree process tree (.ptree).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function discover_non_stochastic_prefix_tree_process_tree.
Ebi filter traces empty

Ebi filter traces empty

Remove empty traces.
Parameters:
<event log> The log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)*
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • csv (comma-separated values)
  • xes.gz (compressed event log)
  • dfa (deterministic finite automaton)
  • xes (extensible event stream)
  • lang (finite language)
  • slang (finite stochastic language)
  • pel (Python event log)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • Python event log (.pel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function filter_traces_empty.
Ebi filter traces event activity

Ebi filter traces event activity

Short alias: Ebi fil tr event act.
Remove traces that have event(s) as specified.
Parameters:
<event log> The log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)*
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<event selector> Which event s in the trace should be the activity.
Accepted values:
  • `all`
  • `any`
  • `end`
  • `none`
  • `start`
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<activity> The activity the filter targets.
Accepted values:
  • text
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • csv (comma-separated values)
  • xes.gz (compressed event log)
  • dfa (deterministic finite automaton)
  • xes (extensible event stream)
  • lang (finite language)
  • slang (finite stochastic language)
  • pel (Python event log)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • Python event log (.pel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function filter_traces_event_activity.
Ebi filter traces length

Ebi filter traces length

Short alias: Ebi fil tr len.
Remove traces that have a given length.
Parameters:
<event log> The log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)*
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<operator> The operator.
Accepted values:
  • `<=`
  • `<>`
  • `<`
  • `=`
  • `>=`
  • `>`
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<value> The value.
Accepted values:
  • integer above 0
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • csv (comma-separated values)
  • xes.gz (compressed event log)
  • dfa (deterministic finite automaton)
  • xes (extensible event stream)
  • lang (finite language)
  • slang (finite stochastic language)
  • pel (Python event log)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • Python event log (.pel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function filter_traces_length.
Ebi information

Ebi information

Short alias: Ebi info.
Show information about a file.
Parameters:
<FILE> Any file supported by ebi.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • executions (.exs)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • language of alignments (.ali)
  • object-centric event log (.ocel)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic language of alignments (.sali)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function information.
Ebi probability explain-trace

Ebi probability explain-trace

Short alias: Ebi prob exptra.
Compute the most likely explanation of a trace given the stochastic model.
Parameters:
<FILE> The model.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<VALUE> Balance between0 only consider deviations to1 only consider weight in the model.
Accepted values:
  • fraction between 0 and 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<TRACE> The trace.
Mandatory: yes.
-o or
--output <FILE>
The language of alignments (.ali) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of language of alignments (.ali).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
Ebi probability log

Ebi probability log

Compute the probability that a stochastic model produces any trace of a log. More information is available in the PDF manual.
Parameters:
<FILE_1> The queriable stochastic language model.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE_2> The finite language log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function probability_log.
Ebi probability trace

Ebi probability trace

Short alias: Ebi prob trac.
Compute the probability of a trace in a stochastic model. More information is available in the PDF manual.
Parameters:
<FILE> The queriable stochastic language model.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<TRACE> The remaining multiple standard arguments after FILE are interpreted as the TRACE. Provide event labels in trace order, separated as normal command line arguments (e.g., a space).
Mandatory: yes.
-o or
--output <FILE>
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
Ebi sample folds

Ebi sample folds

Randomly but reproducibly split a log into a given number of sub-logs. Each trace has a likelihood of 1/folds to end up in any of the folds. Giving the same random seed yields the same split, as long as the same build number of Ebi is used. For instance, one can perform k-fold cross validation: one would repeatedly apply the folds command with the same seed and the same number of folds, but vary the returned sub-logs.
Parameters:
<LOG> The event log.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_FOLDS> The number of folds.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<SEED> The random seed.
Accepted values:
  • integer
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<RETURN_FOLD> The fold to be returned.
Accepted values:
  • integer
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • csv (comma-separated values)
  • xes.gz (compressed event log)
  • dfa (deterministic finite automaton)
  • xes (extensible event stream)
  • lang (finite language)
  • slang (finite stochastic language)
  • pel (Python event log)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • Python event log (.pel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function sample_folds.
Ebi sample partially-ordered-traces

Ebi sample partially-ordered-traces

Short alias: Ebi sam potr.
Sample traces randomly. Please note that this may run forever if the model contains a livelock.
Parameters:
<MODEL> The model with partially ordered semantics to sample from.
Accepted values:
  • stochastic business process model and notation (.sbpmn)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> The number of traces to be sampled.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • spolang (finite stochastic partially ordered language)
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of spolang (finite stochastic partially ordered language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • finite stochastic partially ordered language (.spolang)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is spolang finite stochastic partially ordered language (.spolang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function sample_partially_ordered_traces.
Ebi sample traces

Ebi sample traces

Short alias: Ebi sam tra.
Sample traces randomly. Please note that this may run forever if the model contains a livelock.
Parameters:
<FILE> The stochastic semantics model.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • directly follows graph (.dfg)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<NUMBER_OF_TRACES> The number of traces to be sampled.
Accepted values:
  • integer above 1
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • dfa (deterministic finite automaton)
  • lang (finite language)
  • slang (finite stochastic language)
  • sdfa (stochastic deterministic finite automaton)
  • snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • deterministic finite automaton (.dfa)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function sample_traces.
Ebi test bootstrap-test

Ebi test bootstrap-test

Short alias: Ebi tst btst.
Test the hypothesis that the logs are derived from identical processes. More information is available in the PDF manual.
Parameters:
<LANG_1> The first event log for which the test is to be performed.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<LANG_2> The second event log for which the test is to be performed.
Accepted values:
  • Python event log (.pel)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • finite stochastic language (.slang)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<SAMPLES> The number of samples taken.
Accepted values:
  • integer above 1
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
<P-VALUE> The threshold p value.
Accepted values:
  • fraction between 0 and 1
Mandatory: no. If no value is provided, a default of 1/20 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function test_bootstrap_test.
Ebi test log-categorical-attribute

Ebi test log-categorical-attribute

Short alias: Ebi tst lcat.
Test the hypothesis that the sub-logs defined by the categorical attribute are derived from identical processes. More information is available in the PDF manual.
Parameters:
<FILE> The event log for which the test is to be performed.
Accepted values:
  • compressed event log (.xes.gz)
  • extensible event stream (.xes)
  • object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<ATTRIBUTE> The trace attribute for which the test is to be performed the trace attributes of a log can be found using ebi info.
Accepted values:
  • text
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<SAMPLES> The number of samples taken.
Accepted values:
  • integer above 1
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
<P-VALUE> The threshold p value.
Accepted values:
  • fraction between 0 and 1
Mandatory: no. If no value is provided, a default of 1/20 will be used. It can also be provided on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function test_log_categorical_attribute.
Ebi validate

Ebi validate

Short alias: Ebi vali.
Attempt to parse any file supported by Ebi, and return a parsing error if necessary. If you do not know the type the file should have, try `Ebi info`.
Parameters:
<TYPE> The type for which parsing should be attempted.
Accepted values:
  • the file extension of any file type supported by Ebi (xes.gz, dfg, dfa, dfm, sdfm, exs, sbpmn, bpmn, ocel, xes, lang, slang, spolang, lpn, ali, lola, pnml, sdfa, slpn, ptree, sali, sptree, ptml, csv or snfa)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
<FILE> The file to be parsed.
Mandatory: yes.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
Ebi visualise graph

Ebi visualise graph

Visualise a file as a graph.
Parameters:
<FILE> Any file that can be visualised as a graph.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • business process model and notation (.bpmn)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-t or
--output_type <OUTPUT_TYPE>
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are:
  • pdf (portable document format)
  • png (portable network graphics)
  • svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of svg (scalable vector graphics) will be used.
-o or
--output <FILE>
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be
  • portable document format (.pdf)
  • portable network graphics (.png)
  • scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is svg scalable vector graphics (.svg).
-a or --approximate Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used.
This command is available in the ebi-pm Python package using the function visualise_graph.
Ebi visualise text

Ebi visualise text

Short alias: Ebi vis txt.
Visualise a file as text.
Parameters:
<FILE> Any file that can be visualised textually.
Accepted values:
  • LoLa Petri net (.lola)
  • Petri net markup language (.pnml)
  • Python event log (.pel)
  • business process model and notation (.bpmn)
  • comma-separated values (.csv)
  • compressed event log (.xes.gz)
  • deterministic finite automaton (.dfa)
  • directly follows graph (.dfg)
  • directly follows model (.dfm)
  • executions (.exs)
  • extensible event stream (.xes)
  • finite language (.lang)
  • finite stochastic language (.slang)
  • finite stochastic partially ordered language (.spolang)
  • labelled Petri net (.lpn)
  • language of alignments (.ali)
  • object-centric event log (.ocel)
  • portable document format (.pdf)
  • portable network graphics (.png)
  • process tree (.ptree)
  • process tree markup language (.ptml)
  • scalable vector graphics (.svg)
  • stochastic business process model and notation (.sbpmn)
  • stochastic deterministic finite automaton (.sdfa)
  • stochastic directly follows model (.sdfm)
  • stochastic labelled Petri net (.slpn)
  • stochastic language of alignments (.sali)
  • stochastic non-deterministic finite automaton (.snfa)
  • stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
-o or
--output <FILE>
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
This command is available in the ebi-pm Python package using the function visualise_text.