Using ProB with Atelier B: Difference between revisions

Line 18: Line 18:
** ProB makes use of a unification-based type inference algorithm. As such, typing information can not only flow from left-to-right inside a formula, but also from right-to-left. For example, it is sufficient to type <tt>xx<:yy & yy<:NAT</tt> instead of typing both <tt>xx</tt> and <tt>yy</tt> in ProB.
** ProB makes use of a unification-based type inference algorithm. As such, typing information can not only flow from left-to-right inside a formula, but also from right-to-left. For example, it is sufficient to type <tt>xx<:yy & yy<:NAT</tt> instead of typing both <tt>xx</tt> and <tt>yy</tt> in ProB.
** Similar to Rodin, ProB extracts typing information from all predicates. As such, it is sufficient to write <tt>xx/:{1,2}</tt> to assign a type to <tt>xx</tt>.
** Similar to Rodin, ProB extracts typing information from all predicates. As such, it is sufficient to write <tt>xx/:{1,2}</tt> to assign a type to <tt>xx</tt>.
** the fields of records are normalized (sorted); hence <tt>rec(a:0,b:1) = rec(b:y,a:x)</tt> is not a type error for ProB.
** the fields of records are normalized (sorted); hence the predicate <tt>rec(a:0,b:1) = rec(b:y,a:x)</tt> is correctly typed for ProB.


* DEFINITIONS: the definitions and its arguments are checked by ProB. We believe this to be an important feature for a formal method language. However, as such, every DEFINITION must be either a predicate, an expression or a substitution. You '''cannot''' use, for example, lists of identifiers as a definition. Also, for the moment, the arguments to DEFINITIONS have to be expressions.
* DEFINITIONS: the definitions and its arguments are checked by ProB. We believe this to be an important feature for a formal method language. However, as such, every DEFINITION must be either a predicate, an expression or a substitution. You '''cannot''' use, for example, lists of identifiers as a definition. Also, for the moment, the arguments to DEFINITIONS have to be expressions.

Revision as of 09:31, 31 October 2012


As of version 1.3, ProB contains a much improved parser which tries be compliant with Atelier B as much as possible.

Atelier B Plugin

There is also a plugin for Atelier B for use withthe standalone Tcl/Tk Version on Atelier B projects.

Differences with Atelier B

Extra Features of ProB

  • Identifiers: ProB also allows identifiers consisting of a single letter.
  • Typing:
    • ProB makes use of a unification-based type inference algorithm. As such, typing information can not only flow from left-to-right inside a formula, but also from right-to-left. For example, it is sufficient to type xx<:yy & yy<:NAT instead of typing both xx and yy in ProB.
    • Similar to Rodin, ProB extracts typing information from all predicates. As such, it is sufficient to write xx/:{1,2} to assign a type to xx.
    • the fields of records are normalized (sorted); hence the predicate rec(a:0,b:1) = rec(b:y,a:x) is correctly typed for ProB.
  • DEFINITIONS: the definitions and its arguments are checked by ProB. We believe this to be an important feature for a formal method language. However, as such, every DEFINITION must be either a predicate, an expression or a substitution. You cannot use, for example, lists of identifiers as a definition. Also, for the moment, the arguments to DEFINITIONS have to be expressions.

Limitations

  • Parsing: ProB will require parentheses around the comma, the relational composition, and parallel product operators. For example, you cannot write r2=rel;rel. You need to write r2=(rel;rel). This allows ProB to distinguish the relational composition from the sequential composition (or other uses of the semicolon).
  • Well-definedness: ProB will try to check if your predicates are well-defined during animation or model checking. For this ProB assumes (similar to Rodin) a stricter left-to-right definition of well-definedness than Atelier B.


  • Closure: The transitive and reflexive closure operator of classical B is not supported as defined in the B-Book by Abrial. AtelierB also does not support the operator as defined in the B-Book (as this version cannot be applied in practice). For the reflexive component of closure, ProB will compute the elements in the domain and range of the relation.

Note however, that the transitive closure operator closure1 is fully supported, and hence one can translate an expression closure(e), where e is a binary relation over some domain d, into the expression closure1(e) \/ id(d).

  • Unsupported Operators:
    • Trees and binary trees: These constructs are not supported (the STRING type is now supported);
    • VALUES: This clause of the IMPLEMENTATION machines is not yet supported;