The Verification View provides 3 different methods to test a machine:
In each tab you can add multiple tests to check you currently selected machine and interrupt the checking process by pressing the "Cancel" button.

By pressing the plus button you can add several model checking variants. The following view will be shown:

Select one of the search strategies (breadth first, depth first or a mix of both) and the checkboxes containing different possible errors like deadlocks to be checked for. By pushing the "Model Check" button your selected variant will be added to the list shown at the top of the Modelchecking Tab.

By pressing the "Add LTL Formula" or "Add LTL Pattern" buttons an editor for each respectively will be opened and you can add LTL formulas or patterns to the lists to be checked for.
Supported types: num (non-negative whole numbers), seq (sequences), var (LTL formulae)
Definition of variables: <type> <identifier>: <value>
Assignment of variables: <identifier>: <value>
Scopes for variables: Loop, pattern, global (a lookup for a variable checks the inner scopes first until the variable is found)
Definition of a Pattern:
def `<name>` ( `<parameters>` ):
`<body>`
Each parameter is of the form:
<identifier> : <type> for num and seq variables<identifier> for var variablesThe parameters are separated by a comma. The body contains statements such as definition or assignment of variables as well as loops. Patterns can be overloaded.
<name>( <arguments> )Remark: Pattern Invocations do not depend on the order of the definitions of the used patterns. So patterns can be invoked before they are defined. Patterns can only be defined in the global scope. It is not possible to define patterns within other patterns.
count `<identifier>`: `<start>` `<up/down>` to `<end>`:
`<body>`
end
The body must at least define or assign a variable.
<formulae> )A sequence contains many formulae that must be true in different states. It is not required that the states must come one after another.
must at least contain two formulae.
( <formulae> without <condition> ) <identifier> without <condition>
The first use case extends the definition of a sequence by an additional condition. The second use case requires
to be a name of a variable with the datatype seq. The sequence stored in the variable are used to define a new sequence where the condition is true.
<argument> )
is a variable of the type seq or a definition of a sequence. Invoking a sequence returns a LTL formula.
before(
<right endpoint>,<property>) after(<left endpoint>,<property>) between(<left endpoint>,<right endpoint>,<property>) after_until(<left endpoint>,<right endpoint>,<property>)
The endpoints and properties must be regular LTL formulae. The return value of a scope is a regular LTL formula where the given conditions are true.
One-line comment : // comment
Multiline comment: /* comment */
Examples:
Example with LTL formula:
//To describe a portion of a system's execution which contains only states that have a desired property. Also known as Henceforth and Always.
def universality(p):
G(p)
Example with loops and overloading:
//To describe a portion of a system's execution that contains an instance of certain events or states. Also known as Eventually.
//With a given n, you can describe, that a certain state can occur at most n-times.
def existence(p):
F(p)
def existence(p, n : num):
var result: G(!p)
count 0 up to n:
result: !p W (p W result)
end
result
Example with sequence invocation and overloading:
//To describe cause-effect relationships between a pair of events/states. An occurrence of the first, the cause, must be followed by an occurrence of the second, the effect. Also known as Follows and Leads-to.
//With a given sequence of states, you can describe, that e.g. the sequence of states follows a certain state.
def response(s, p):
G(p => F(s))
def response(s : seq, p):
G(p => F(seq(s)))
def response(s, p : seq):
G(seq(p) => F(s))

By pressing the plus button you can add several symbolic checking variants. The following view will be shown:

The dropdown menu allows you to select the type of check. Some variants of the symbolic checking might need additional parameters (e.g. Invariant needs an operation).