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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_all_traces(<FILE>)
Javascript/online/NPM	function analyse_all_traces(<FILE> as a string, output_file_extension)
Java	not available

Ebi analyse cohort-analysis

Short alias: Ebi ana ca.

Returns which trace attribute values correspond with the largest behavioural differences. Only categorical attributes are supported. A lower EMSC value indicates a larger difference. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ocel, .xes, .xes.gz
<RNDSPL>		integer equal to or above 0
<MINSIZ>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

Parameters

<FILE>	An event log with trace attributes. 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.
<RNDSPL>	The size of cohorts may have an influence on the measured distances to correct for this these measures can be scaled by randomly generated cohorts of the same size this parameter sets the number of such random splits set this to0 to not perform this correction. Accepted values: integer above 0 Mandatory: no. If no value is provided, a default of 10 will be used. It can also be provided on STDIN by giving a `-' on the command line.
<MINSIZ>	The minimum number of traces per cohort as a fraction of the total number of traces in case the cohort or its complement contains fewer traces it is left out. 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_cohort_analysis(<FILE>, <RNDSPL>, <MINSIZ>)
Javascript/online/NPM	function analyse_cohort_analysis(<FILE> as a string, <RNDSPL> as a string, <MINSIZ> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse cohort-analysis", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .ocel, .pel, .xes, .xes.gz

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_completeness(<FILE>)
Javascript/online/NPM	function analyse_completeness(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse completeness", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<MINIMUM_COVERAGE>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_coverage(<FILE>, <MINIMUM_COVERAGE>)
Javascript/online/NPM	function analyse_coverage(<FILE> as a string, <MINIMUM_COVERAGE> as a string, output_file_extension)
Java	not available

Ebi analyse directly-follows-edge-difference

Short alias: Ebi ana dfgedi.

The number of edges that differ between two directly follows graphs.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<DFG_1>		.dfg
<DFG_2>		.dfg

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_directly_follows_edge_difference(<DFG_1>, <DFG_2>)
Javascript/online/NPM	function analyse_directly_follows_edge_difference(<DFG_1> as a string, <DFG_2> as a string, output_file_extension)
Java	not available

Ebi analyse directly-follows-edge-difference-no-frequencies

Short alias: Ebi ana dfgedi-nf.

The number of edges that differ between two directly follows graphs, ignoring frequencies.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<DFG_1>		.dfg
<DFG_2>		.dfg

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_directly_follows_edge_difference_no_frequencies(<DFG_1>, <DFG_2>)
Javascript/online/NPM	function analyse_directly_follows_edge_difference_no_frequencies(<DFG_1> as a string, <DFG_2> as a string, output_file_extension)
Java	not available

Ebi analyse entropy

Short alias: Ebi ana en.

Computes the entropy $H$ of the object. That is, the average number of bits that is required to encode a randomly drawn trace, given the object. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<STOCH>		.csv, .dfg, .ocel, .pel, .sdfa, .slang, .xes, .xes.gz

Error:

Result: (download)

Parameters

<STOCH>	The object. 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.
-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 logpolynomial (.logpol).
-a or --approximate	Use approximate arithmetic instead of exact arithmetic. Mandatory: no. If not provided, exact arithmetic will be used.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_entropy(<STOCH>)
Javascript/online/NPM	function analyse_entropy(<STOCH> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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 above 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: 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_medoid(<FILE>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function analyse_medoid(<FILE> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	not available

Ebi analyse minimum-probability-traces

Short alias: Ebi ana minprob.

Find all traces that have a given minimum probability. Will return a finite 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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<MINIMUM_PROBABILITY>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_minimum_probability_traces(<FILE>, <MINIMUM_PROBABILITY>)
Javascript/online/NPM	function analyse_minimum_probability_traces(<FILE> as a string, <MINIMUM_PROBABILITY> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_mode(<FILE>)
Javascript/online/NPM	function analyse_mode(<FILE> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_most_likely_traces(<FILE>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function analyse_most_likely_traces(<FILE> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .ocel, .pel, .slang, .xes, .xes.gz

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_variety(<FILE>)
Javascript/online/NPM	function analyse_variety(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse variety", String output_format, String[] inputs);

Ebi analyse-non-stochastic activities

Short alias: Ebi anans act.

Shows the activities that are declared in the object.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ali, .bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sali, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_activities(<FILE>)
Javascript/online/NPM	function analyse_non_stochastic_activities(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic activities", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<MODEL>		.csv, .dfa, .dfg, .dfm, .lang, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_any_traces(<MODEL>)
Javascript/online/NPM	function analyse_non_stochastic_any_traces(<MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic any-traces", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<MODEL>		.csv, .dfa, .dfg, .dfm, .lang, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_bounded(<MODEL>)
Javascript/online/NPM	function analyse_non_stochastic_bounded(<MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic bounded", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANGUAGE>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<NUMBER_OF_CLUSTERS>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_cluster(<LANGUAGE>, <NUMBER_OF_CLUSTERS>)
Javascript/online/NPM	function analyse_non_stochastic_cluster(<LANGUAGE> as a string, <NUMBER_OF_CLUSTERS> as a string, output_file_extension)
Java	not available

Ebi analyse-non-stochastic empty-traces

Short alias: Ebi anans et.

Returns wheter the log or model contains empty traces.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ptml, .ptree, .sptree

Error:

Result: (download)

Parameters

<FILE>	A file. 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.
-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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_empty_traces(<FILE>)
Javascript/online/NPM	function analyse_non_stochastic_empty_traces(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic empty-traces", String output_format, String[] inputs);

Ebi analyse-non-stochastic executions

Short alias: Ebi anans exs.

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .ocel, .pel, .xes, .xes.gz
<MODEL>		.bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz

Error:

Result: (download)

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.
<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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_executions(<LOG>, <MODEL>)
Javascript/online/NPM	function analyse_non_stochastic_executions(<LOG> as a string, <MODEL> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<MODEL>		.csv, .dfa, .dfg, .dfm, .lang, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_infinitely_many_traces(<MODEL>)
Javascript/online/NPM	function analyse_non_stochastic_infinitely_many_traces(<MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic infinitely-many-traces", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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 above 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: 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_medoid(<FILE>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function analyse_non_stochastic_medoid(<FILE> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	not available

Ebi analyse-non-stochastic timestamps-ordered

Short alias: Ebi anans to.

Check whether all timestamps are in a correct order.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .exs, .ocel, .pel, .xes, .xes.gz

Error:

Result: (download)

Parameters

<LOG>	The event log. Accepted values: Python event log (.pel) comma-separated values (.csv) compressed event log (.xes.gz) executions (.exs) 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 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function analyse_non_stochastic_timestamps_ordered(<LOG>)
Javascript/online/NPM	function analyse_non_stochastic_timestamps_ordered(<LOG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi analyse-non-stochastic timestamps-ordered", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ocel, .xes, .xes.gz
<SAMPLES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function association_all_trace_attributes(<FILE>, <SAMPLES>)
Javascript/online/NPM	function association_all_trace_attributes(<FILE> as a string, <SAMPLES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi association all-trace-attributes", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ocel, .xes, .xes.gz
<ATTRIBUTE>
<SAMPLES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function association_trace_attribute(<FILE>, <ATTRIBUTE>, <SAMPLES>)
Javascript/online/NPM	function association_trace_attribute(<FILE> as a string, <ATTRIBUTE> as a string, <SAMPLES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi association trace-attribute", String output_format, String[] inputs);

Ebi conformance chi-squared

Short alias: Ebi conf cssc.

Compute chi-square stochastic conformance. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_chi_squared(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_chi_squared(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance chi-squared", String output_format, String[] inputs);

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`. Livelocks are silently ignored. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_chi_squared_sample(<FILE_1>, <FILE_2>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function conformance_chi_squared_sample(<FILE_1> as a string, <FILE_2> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance chi-squared-sample", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .spolang, .xes, .xes.gz
<SLANG>		.csv, .ocel, .pel, .slang, .spolang, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<SLANG>	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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_earth_movers(<SLANG>, <SLANG>)
Javascript/online/NPM	function conformance_earth_movers(<SLANG> as a string, <SLANG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance earth-movers", String output_format, String[] inputs);

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`. Livelocks are silently ignored. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_earth_movers_sample(<FILE_1>, <FILE_2>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function conformance_earth_movers_sample(<FILE_1> as a string, <FILE_2> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance earth-movers-sample", String output_format, String[] inputs);

Ebi conformance entropic-relevance

Short alias: Ebi conf er.

Compute entropic relevance (uniform). More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	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 logpolynomial (.logpol).
-a or --approximate	Use approximate arithmetic instead of exact arithmetic. Mandatory: no. If not provided, exact arithmetic will be used.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_entropic_relevance(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_entropic_relevance(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	not available

Ebi conformance gain-precision

Short alias: Ebi conf gp.

Compute gain-based precision for a finite stochastic language and an SDFA. If the SDFA supports less than two traces, set lambda to a small non-zero value. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .slang, .xes, .xes.gz
<LAMBDA>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	A stochastic deterministic finite automaton s d f a 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) 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.
<LAMBDA>	The smoothing parameter if the s d f a supports less than two traces set this to a small value. Accepted values: fraction between 0 and 1 Mandatory: no. If no value is provided, a default of 0 will be used. It can also be provided 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 logpolynomial (.logpol).

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_gain_precision(<SLANG>, <MODEL>, <LAMBDA>)
Javascript/online/NPM	function conformance_gain_precision(<SLANG> as a string, <MODEL> as a string, <LAMBDA> as a string, output_file_extension)
Java	not available

Ebi conformance gain-recall

Short alias: Ebi conf gr.

Compute gain-based recall for a finite stochastic language and an SDFA. If the SDFA supports less than two traces, set lambda to a small non-zero value. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .slang, .xes, .xes.gz
<LAMBDA>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	A stochastic deterministic finite automaton s d f a 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) 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.
<LAMBDA>	The smoothing parameter if the s d f a supports less than two traces set this to a small value. Accepted values: fraction between 0 and 1 Mandatory: no. If no value is provided, a default of 0 will be used. It can also be provided 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 logpolynomial (.logpol).

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_gain_recall(<SLANG>, <MODEL>, <LAMBDA>)
Javascript/online/NPM	function conformance_gain_recall(<SLANG> as a string, <MODEL> as a string, <LAMBDA> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_hellinger(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_hellinger(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance hellinger", String output_format, String[] inputs);

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`. Livelocks are silently ignored. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_hellinger_sample(<FILE_1>, <FILE_2>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function conformance_hellinger_sample(<FILE_1> as a string, <FILE_2> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance hellinger-sample", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	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).

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_jensen_shannon(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_jensen_shannon(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance jensen-shannon", String output_format, String[] inputs);

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`. Livelocks are silently ignored. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1

Error:

Result: (download)

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).

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_jensen_shannon_sample(<FILE_1>, <FILE_2>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function conformance_jensen_shannon_sample(<FILE_1> as a string, <FILE_2> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance jensen-shannon-sample", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<K_ORDER>		integer equal to or above 1
<MEASURE>

Error:

Result: (download)

Parameters

<FILE_1>	A finite stochastic language or a stochastic labelled petri net log to compare a model 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 a model 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_markovian(<FILE_1>, <FILE_2>, <K_ORDER>, <MEASURE>)
Javascript/online/NPM	function conformance_markovian(<FILE_1> as a string, <FILE_2> as a string, <K_ORDER> as a string, <MEASURE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance markovian", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz

Error:

Result: (download)

Parameters

<SLANG>	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.
<MODEL>	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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_unit_earth_movers(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_unit_earth_movers(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance unit-earth-movers", String output_format, String[] inputs);

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`. Livelocks are silently ignored. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_unit_earth_movers_sample(<FILE_1>, <FILE_2>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function conformance_unit_earth_movers_sample(<FILE_1> as a string, <FILE_2> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi conformance unit-earth-movers-sample", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MODEL>		.bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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.
<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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_non_stochastic_alignments(<SLANG>, <MODEL>)
Javascript/online/NPM	function conformance_non_stochastic_alignments(<SLANG> as a string, <MODEL> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<ALIGNMENTS>		.sali
<MODEL>		.bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_non_stochastic_escaping_edges_precision(<ALIGNMENTS>, <MODEL>)
Javascript/online/NPM	function conformance_non_stochastic_escaping_edges_precision(<ALIGNMENTS> as a string, <MODEL> as a string, output_file_extension)
Java	not available

Ebi conformance-non-stochastic fitting-traces

Short alias: Ebi confns fitt.

Compute the fraction of fitting traces in a stochastic language of alignments: the fraction of traces that have only synchronous and silent moves.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<ALIGNMENTS>		.sali

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_non_stochastic_fitting_traces(<ALIGNMENTS>)
Javascript/online/NPM	function conformance_non_stochastic_fitting_traces(<ALIGNMENTS> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<FILE_2>		.bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_non_stochastic_set_alignments(<FILE_1>, <FILE_2>)
Javascript/online/NPM	function conformance_non_stochastic_set_alignments(<FILE_1> as a string, <FILE_2> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<ALIGNMENTS>		.sali

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function conformance_non_stochastic_trace_fitness(<ALIGNMENTS>)
Javascript/online/NPM	function conformance_non_stochastic_trace_fitness(<ALIGNMENTS> as a string, output_file_extension)
Java	not available

Ebi convert business-process-model-and-notation

Short alias: Ebi conv bpmn.

Convert an object to a Business Process Model and Notation.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.bpmn, .dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa*, .sptree
<OUTPUT>

Error:

Result: (download)

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)* partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_business_process_model_and_notation(<FILE>)
Javascript/online/NPM	function convert_business_process_model_and_notation(<FILE> as a string, output_file_extension)
Java	not available

Ebi convert finite-language

Short alias: Ebi conv lang.

Convert an object to a finite language.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .lang, .ocel, .pel, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_finite_language(<FILE>)
Javascript/online/NPM	function convert_finite_language(<FILE> as a string, output_file_extension)
Java	not available

Ebi convert finite-stochastic-language

Short alias: Ebi conv slang.

Convert an object to a finite stochastic language.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_finite_stochastic_language(<FILE>)
Javascript/online/NPM	function convert_finite_stochastic_language(<FILE> as a string, output_file_extension)
Java	not available

Ebi convert labelled-petri-net

Short alias: Ebi conv lpn.

Convert an object to a labelled Petri net.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_labelled_petri_net(<FILE>)
Javascript/online/NPM	function convert_labelled_petri_net(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi convert labelled-petri-net", String output_format, String[] inputs);

Ebi convert log

Convert an object to an event log, considering only its traces.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .ocel, .pel, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_log(<FILE>)
Javascript/online/NPM	function convert_log(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi convert log", String output_format, String[] inputs);

Ebi convert stochastic-deterministic-finite-automaton

Short alias: Ebi conv sdfa.

Convert an object to a stochastic deterministic finite automaton.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_stochastic_deterministic_finite_automaton(<FILE>)
Javascript/online/NPM	function convert_stochastic_deterministic_finite_automaton(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi convert stochastic-deterministic-finite-automaton", String output_format, String[] inputs);

Ebi convert stochastic-directly-follows-model

Short alias: Ebi conv sdfm.

Convert an object to a stochastic directly follows model.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.dfg, .sdfm
<OUTPUT>

Error:

Result: (download)

Parameters

<FILE>	Any file supported by ebi that can be converted an s l p n must be livelock free and bounded. Accepted values: directly follows graph (.dfg) stochastic directly follows model (.sdfm) 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) 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) sdfm (stochastic directly follows model) slpn (stochastic labelled Petri net) snfa (stochastic non-deterministic finite automaton) Mandatory: no. If no value is provided, the default of sdfm (stochastic directly follows model) 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 model (.dfm) labelled Petri net (.lpn) LoLa Petri net (.lola) Petri net markup language (.pnml) portable document format (.pdf) portable network graphics (.png) stochastic directly follows model (.sdfm) 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 sdfm stochastic directly follows model (.sdfm).
-a or --approximate	Use approximate arithmetic instead of exact arithmetic. Mandatory: no. If not provided, exact arithmetic will be used.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_stochastic_directly_follows_model(<FILE>)
Javascript/online/NPM	function convert_stochastic_directly_follows_model(<FILE> as a string, output_file_extension)
Java	not available

Ebi convert stochastic-labelled-petri-net

Short alias: Ebi conv slpn.

Convert an object to a stochastic labelled Petri net.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.dfg, .sdfa, .sdfm, .slpn, .snfa
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_stochastic_labelled_petri_net(<FILE>)
Javascript/online/NPM	function convert_stochastic_labelled_petri_net(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi convert stochastic-labelled-petri-net", String output_format, String[] inputs);

Ebi convert stochastic-nondeterministic-finite-automaton

Short alias: Ebi conv snfa.

Convert an object to a stochastic nondeterministic finite automaton.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function convert_stochastic_nondeterministic_finite_automaton(<FILE>)
Javascript/online/NPM	function convert_stochastic_nondeterministic_finite_automaton(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi convert stochastic-nondeterministic-finite-automaton", String output_format, String[] inputs);

Ebi discover alergia

Short alias: Ebi disc al.

Learns a Stochastic Deterministic Finite Automaton (SDFA) from an event log using the Alergia algorithm, which iteratively merges statistically similar states of the log's frequency prefix tree. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .ocel, .pel, .xes, .xes.gz
<ALPHA>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

Parameters

<LOG>	An event log to discover the model from. 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.
<ALPHA>	Confidence level. 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.
-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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_alergia(<LOG>, <ALPHA>)
Javascript/online/NPM	function discover_alergia(<LOG> as a string, <ALPHA> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover alergia", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<BPMN>		.bpmn, .dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa*, .sptree
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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 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)* partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_alignments_stochastic_business_process_model_and_notation(<SLANG>, <BPMN>)
Javascript/online/NPM	function discover_alignments_stochastic_business_process_model_and_notation(<SLANG> as a string, <BPMN> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<LPN>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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.
<LPN>	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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_alignments_stochastic_labelled_petri_nets(<SLANG>, <LPN>)
Javascript/online/NPM	function discover_alignments_stochastic_labelled_petri_nets(<SLANG> as a string, <LPN> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover alignments stochastic-labelled-Petri-nets", String output_format, String[] inputs);

Ebi discover directly-follows-graph

Short alias: Ebi disc dfg.

Discover a directly follows graph. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<MIN_FITNESS>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_directly_follows_graph(<SLANG>, <MIN_FITNESS>)
Javascript/online/NPM	function discover_directly_follows_graph(<SLANG> as a string, <MIN_FITNESS> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover directly-follows-graph", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<BPMN>		.bpmn, .dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa*, .sptree
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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)* partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_occurrence_stochastic_business_process_model_and_notation(<SLANG>, <BPMN>)
Javascript/online/NPM	function discover_occurrence_stochastic_business_process_model_and_notation(<SLANG> as a string, <BPMN> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<LPN>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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.
<LPN>	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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_occurrence_stochastic_labelled_petri_net(<SLANG>, <LPN>)
Javascript/online/NPM	function discover_occurrence_stochastic_labelled_petri_net(<SLANG> as a string, <LPN> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover occurrence stochastic-labelled-Petri-net", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<TREE>		.ptml, .ptree, .sptree
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_occurrence_stochastic_process_tree(<SLANG>, <TREE>)
Javascript/online/NPM	function discover_occurrence_stochastic_process_tree(<SLANG> as a string, <TREE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover occurrence stochastic-process-tree", String output_format, String[] inputs);

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).

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<BPMN>		.bpmn, .dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa*, .sptree
<OUTPUT>

Error:

Result: (download)

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)* partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_random_stochastic_business_process_model_and_notation(<BPMN>)
Javascript/online/NPM	function discover_random_stochastic_business_process_model_and_notation(<BPMN> as a string, output_file_extension)
Java	not available

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).

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LPN>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_random_stochastic_labelled_petri_net(<LPN>)
Javascript/online/NPM	function discover_random_stochastic_labelled_petri_net(<LPN> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover random stochastic-labelled-Petri-net", String output_format, String[] inputs);

Ebi discover random stochastic-process-tree

Short alias: Ebi disc rnd sptree.

Give each leaf a random weight between 0 (exclusive) and 1 (inclusive).

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<TREE>		.ptml, .ptree, .sptree
<OUTPUT>

Error:

Result: (download)

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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_random_stochastic_process_tree(<TREE>)
Javascript/online/NPM	function discover_random_stochastic_process_tree(<TREE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover random stochastic-process-tree", String output_format, String[] inputs);

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

Short alias: Ebi disc uni sbpmn.

Give each sequence flow a weight of 1.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<BPMN>		.bpmn, .dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa*, .sptree
<OUTPUT>

Error:

Result: (download)

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)* partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_uniform_stochastic_business_process_model_and_notation(<BPMN>)
Javascript/online/NPM	function discover_uniform_stochastic_business_process_model_and_notation(<BPMN> as a string, output_file_extension)
Java	not available

Ebi discover uniform stochastic-labelled-Petri-net

Short alias: Ebi disc uni slpn.

Give each transition a weight of 1.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LPN>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_uniform_stochastic_labelled_petri_net(<LPN>)
Javascript/online/NPM	function discover_uniform_stochastic_labelled_petri_net(<LPN> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover uniform stochastic-labelled-Petri-net", String output_format, String[] inputs);

Ebi discover uniform stochastic-process-tree

Short alias: Ebi disc uni sptree.

Give each leaf a weight of 1 in a process tree.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<TREE>		.ptml, .ptree, .sptree
<OUTPUT>

Error:

Result: (download)

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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_uniform_stochastic_process_tree(<TREE>)
Javascript/online/NPM	function discover_uniform_stochastic_process_tree(<TREE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover uniform stochastic-process-tree", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ali, .bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sali, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_flower_deterministic_finite_automaton(<FILE>)
Javascript/online/NPM	function discover_non_stochastic_flower_deterministic_finite_automaton(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic flower deterministic-finite-automaton", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ali, .bpmn, .csv, .dfa, .dfg, .dfm, .lang, .lola, .lpn, .ocel, .pel, .pnml, .powl, .ptml, .ptree, .sali, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_flower_process_tree(<FILE>)
Javascript/online/NPM	function discover_non_stochastic_flower_process_tree(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic flower process-tree", String output_format, String[] inputs);

Ebi discover-non-stochastic inductive-miner

Short alias: Ebi dins im.

Discover a process tree using the Inductive Miner. Please note that this implementation closely follows the thesis version; it is not equivalent to the ProM implementation. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANG>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_inductive_miner(<LANG>)
Javascript/online/NPM	function discover_non_stochastic_inductive_miner(<LANG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic inductive-miner", String output_format, String[] inputs);

Ebi discover-non-stochastic inductive-miner-infrequent

Short alias: Ebi dins imf.

Discover a process tree using the Inductive Miner-infrequent algorithm. If the given noise parameter is 0, then behaves as the Inductive Miner algorithm. Please note that this implementation closely follows the thesis version; it is not equivalent to the ProM implementation. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<SLANG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<NOISE>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

Parameters

<SLANG>	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.
<NOISE>	The amount of noise filtering where0 means no noise filtering is applied and1 means that maximum noise filtering is applied. Accepted values: fraction between 0 and 1 Mandatory: no. If no value is provided, a default of 2/10 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) lpn (labelled Petri net) lola (LoLa Petri net) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_inductive_miner_infrequent(<SLANG>, <NOISE>)
Javascript/online/NPM	function discover_non_stochastic_inductive_miner_infrequent(<SLANG> as a string, <NOISE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic inductive-miner-infrequent", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANG>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_prefix_tree_deterministic_finite_automaton(<LANG>)
Javascript/online/NPM	function discover_non_stochastic_prefix_tree_deterministic_finite_automaton(<LANG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic prefix-tree deterministic-finite-automaton", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANG>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_prefix_tree_process_tree(<LANG>)
Javascript/online/NPM	function discover_non_stochastic_prefix_tree_process_tree(<LANG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic prefix-tree process-tree", String output_format, String[] inputs);

Ebi discover-non-stochastic split-miner

Short alias: Ebi dins sm.

Apply a simplified version of the Split Miner algorithm. In this implementation, it is not necessary to have a unique start and end activity. For now, this implementation does not reduce splits or SESE fragments (Algorithms 8 and 9). More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<CONC>		float or fraction between 0 (inclusive) and 1 (inclusive).
<FREQ>		float or fraction between 0 (inclusive) and 1 (inclusive).
<OUTPUT>

Error:

Result: (download)

Parameters

<LOG>	The 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.
<CONC>	Parallelism threshold. Accepted values: fraction between 0 and 1 Mandatory: no. If no value is provided, a default of 1/10 will be used. It can also be provided on STDIN by giving a `-' on the command line.
<FREQ>	Frequency threshold. Accepted values: fraction between 0 and 1 Mandatory: no. If no value is provided, a default of 4/10 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) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_split_miner(<LOG>, <CONC>, <FREQ>)
Javascript/online/NPM	function discover_non_stochastic_split_miner(<LOG> as a string, <CONC> as a string, <FREQ> as a string, output_file_extension)
Java	not available

Ebi discover-non-stochastic trace-model

Short alias: Ebi dins tm.

Discover a model that is a choice between all traces of the model.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANG>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function discover_non_stochastic_trace_model(<LANG>)
Javascript/online/NPM	function discover_non_stochastic_trace_model(<LANG> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi discover-non-stochastic trace-model", String output_format, String[] inputs);

Ebi filter traces empty

Remove empty traces.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<event log>		.csv*, .pel, .xes, .xes.gz
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function filter_traces_empty(<event log>)
Javascript/online/NPM	function filter_traces_empty(<event log> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi filter traces empty", String output_format, String[] inputs);

Ebi filter traces event activity

Short alias: Ebi fil tr event act.

Remove traces that have event(s) as specified.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<event log>		.csv*, .pel, .xes, .xes.gz
<event selector>
<activity>
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function filter_traces_event_activity(<event log>, <event selector>, <activity>)
Javascript/online/NPM	function filter_traces_event_activity(<event log> as a string, <event selector> as a string, <activity> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi filter traces event activity", String output_format, String[] inputs);

Ebi filter traces length

Short alias: Ebi fil tr len.

Remove traces that have a given length.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<event log>		.csv*, .pel, .xes, .xes.gz
<operator>
<value>		integer equal to or above 0
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function filter_traces_length(<event log>, <operator>, <value>)
Javascript/online/NPM	function filter_traces_length(<event log> as a string, <operator> as a string, <value> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi filter traces length", String output_format, String[] inputs);

Ebi information

Short alias: Ebi info.

Show information about a file.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ali, .bpmn, .csv, .dfa, .dfg, .dfm, .exs, .lang, .lola, .lpn, .ocel, .pdf, .pel, .png, .pnml, .powl, .ptml, .ptree, .sali, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .svg, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function information(<FILE>)
Javascript/online/NPM	function information(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi information", String output_format, String[] inputs);

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	not available
Javascript/online/NPM	not available
Java	not available

Ebi probability log

Compute the probability that a stochastic model produces any trace of a log. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE_1>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<FILE_2>		.csv, .lang, .ocel, .pel, .slang, .xes, .xes.gz

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function probability_log(<FILE_1>, <FILE_2>)
Javascript/online/NPM	function probability_log(<FILE_1> as a string, <FILE_2> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi probability log", String output_format, String[] inputs);

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	not available
Javascript/online/NPM	not available
Java	not available

Ebi reduce labelled-petri-net

Short alias: Ebi red lpn.

Reduce a labelled Petri net language-equivalently, using adapted Murata rules, which remove certain places and silent transitions. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LPN>		.dfa, .dfg, .dfm, .lpn, .pnml, .powl, .ptml, .ptree, .sdfa, .sdfm, .slpn, .sptree
<OUTPUT>

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function reduce_labelled_petri_net(<LPN>)
Javascript/online/NPM	function reduce_labelled_petri_net(<LPN> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi reduce labelled-petri-net", String output_format, String[] inputs);

Ebi reduce process-tree

Short alias: Ebi red ptr.

Reduce a process tree language-equivalently. More information is available in the PDF manual.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<TREE>		.ptml, .ptree, .sptree
<OUTPUT>

Error:

Result: (download)

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) lpn (labelled Petri net) lola (LoLa Petri net) powl (partially ordered workflow language) 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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function reduce_process_tree(<TREE>)
Javascript/online/NPM	function reduce_process_tree(<TREE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi reduce process-tree", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .ocel, .pel, .xes, .xes.gz
<NUMBER_OF_FOLDS>		integer equal to or above 1
<SEED>		integer equal to or above 0
<RETURN_FOLD>		integer equal to or above 0
<OUTPUT>

Error:

Result: (download)

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 above 0 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 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function sample_folds(<LOG>, <NUMBER_OF_FOLDS>, <SEED>, <RETURN_FOLD>)
Javascript/online/NPM	function sample_folds(<LOG> as a string, <NUMBER_OF_FOLDS> as a string, <SEED> as a string, <RETURN_FOLD> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi sample folds", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<MODEL>		.sbpmn
<NUMBER_OF_TRACES>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function sample_partially_ordered_traces(<MODEL>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function sample_partially_ordered_traces(<MODEL> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	not available

Ebi sample traces

Short alias: Ebi sam tra.

Sample traces randomly. If a livelock is hit, restarts the sampling for that trace. Exception: for BPMN models with a livelock, the computation may run forever.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<NUMBER_OF_TRACES>		integer equal to or above 1
<OUTPUT>

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function sample_traces(<FILE>, <NUMBER_OF_TRACES>)
Javascript/online/NPM	function sample_traces(<FILE> as a string, <NUMBER_OF_TRACES> as a string, output_file_extension)
Java	not available

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LANG_1>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<LANG_2>		.csv, .ocel, .pel, .slang, .xes, .xes.gz
<SAMPLES>		integer equal to or above 1
<P-VALUE>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function test_bootstrap_test(<LANG_1>, <LANG_2>, <SAMPLES>, <P-VALUE>)
Javascript/online/NPM	function test_bootstrap_test(<LANG_1> as a string, <LANG_2> as a string, <SAMPLES> as a string, <P-VALUE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi test bootstrap-test", String output_format, String[] inputs);

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.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ocel, .xes, .xes.gz
<ATTRIBUTE>
<SAMPLES>		integer equal to or above 1
<P-VALUE>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function test_log_categorical_attribute(<FILE>, <ATTRIBUTE>, <SAMPLES>, <P-VALUE>)
Javascript/online/NPM	function test_log_categorical_attribute(<FILE> as a string, <ATTRIBUTE> as a string, <SAMPLES> as a string, <P-VALUE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi test log-categorical-attribute", String output_format, String[] inputs);

Ebi test permutation-test-log-model

Short alias: Ebi tst perm-l-m.

Test the hypothesis that the log and model are derived from identical processes. In case the model contains livelocks, these are silently ignored.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<LOG>		.csv, .ocel, .pel, .xes, .xes.gz
<MODEL>		.csv, .dfg, .ocel, .pel, .sdfa, .sdfm, .slang, .slpn, .snfa, .sptree, .xes, .xes.gz
<SAMPLES>		integer equal to or above 1
<P-VALUE>		float or fraction between 0 (inclusive) and 1 (inclusive).

Error:

Result: (download)

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.
<MODEL>	The stochastic model to sample from. 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.
<SAMPLES>	The number of samples permutations to execute. 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function test_permutation_test_log_model(<LOG>, <MODEL>, <SAMPLES>, <P-VALUE>)
Javascript/online/NPM	function test_permutation_test_log_model(<LOG> as a string, <MODEL> as a string, <SAMPLES> as a string, <P-VALUE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi test permutation-test-log-model", String output_format, String[] inputs);

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, snfa or powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	not available
Javascript/online/NPM	not available
Java	not available

Ebi visualise graph

Visualise a file as a graph.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.bpmn, .dfa, .dfg, .dfm, .lola, .lpn, .pnml, .powl, .ptml, .ptree, .sbpmn, .sdfa, .sdfm, .slpn, .snfa, .spolang, .sptree

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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.

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function visualise_graph(<FILE>)
Javascript/online/NPM	function visualise_graph(<FILE> as a string, output_file_extension)
Java	not available

Ebi visualise text

Short alias: Ebi vis txt.

Visualise a file as text.

Run online

This command can be run here, in the browser. All files remain on your computer, and are not uploaded. There is a limit of 4GB of RAM.

<FILE>		.ali, .bpmn, .csv, .dfa, .dfg, .dfm, .exs, .lang, .lola, .lpn, .ocel, .pdf, .pel, .png, .pnml, .powl, .ptml, .ptree, .sali, .sbpmn, .sdfa, .sdfm, .slang, .slpn, .snfa, .spolang, .sptree, .svg, .xes, .xes.gz

Error:

Result: (download)

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) partially ordered workflow language (.powl) 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).

Availability

Command-line interface	available, with all parameters mentioned above
PM4Py/Python/PyPI	function visualise_text(<FILE>)
Javascript/online/NPM	function visualise_text(<FILE> as a string, output_file_extension)
Java	function call_ebi_internal("Ebi visualise text", String output_format, String[] inputs);