Formal Specification of Multi-Level Constructs

Although multi-level approaches often build upon different formalism and underlying theory, if we examine them at a higher abstraction level, we can grasp the essential concepts that we can use to describe the different approaches in a unified way. The described formalism is not a replacement for any of the approaches, but rather the foundation of a multi-level modeling playground that can be used to experiment with different concepts and ideas in multi-level modeling. The formalism specifies the essence of the different constructs, allowing them to be compared, combined, analyzed, and to be experimented with. We differentiate between two components of a multi-level construct: i) structure and ii) semantics. We use Abstract State Machines for describing both, aiming to achieve a general way to describe the essence of multi-level constructs.

Underlying Structure

The structure of a multi-level construct consists of the underlying modeling structure (e.g., nodes, edges, fields) and of the construct itself (e.g., classic potency, leap potency). Multi-level constructs are usually interpreted over a defined modeling structure like the OCA [AK02], hence the distinction of the underlying structure.

The structure is represented as a Labeled Directed Graph [EEPT06]; an Abstract State Machine (ASM) operates on the graph as its data structure.

Definition 3.2.1. The superuniverse |A| of state A consists of the following uni-verses:

• U_bool consisting of the boolean constants true and f alse

• U_number consisting of integer numbers {N} and the symbol ∞ representing infinity

• U_string consisting of finite length character sequences

• U_ID consisting of valid identifiers

• Ubase =Ubool∪Unumber∪Ustring∪UID, defined only as an auxiliary universe Definition 3.2.2. The nodes of the Labeled Directed Graph partially consist of structural entities with a unique identifier and a structural meta type repre-senting the multi-level nature of the model. A structural entity can contain struc-tural attributesthat also have an identifier and a structural meta type, in addition to being able to contain a value. Complex structural attributes can also con-tain other structural attributes. The nodes of the graph consist also of structural attributes. Both structural entities and structural attributes are capable of holding annotations and annotation definitions.

Remark. As we will see later, containment relations are realized using identifiers.

For example, the label structure of a structural entity contains the identifiers of all of its structural attributes. Moreover, structural attributes are not atomic data, they appear as virtual nodes in the graph, with the structural entity containing them being the root node. The values of structural attributes however consist of elements from

|A|. Virtual nodes are nodes that are not part of the core label structure, yet are still represented as nodes in the graph.

The following is the label structure used by both structural entities and structural attributes, notated byEAtt_N:

• EAtt_ID: the globally unique ID of the element the value is taken fromUID

• EAtt_{N ame}: the locally unique ID of the element the value is taken fromU_ID

• EAttM eta: the structural meta type of the element the value is taken fromU_ID

• EAtt_Attributes: the list of structural attributes of the element the values are taken from UID

• EAttAnnotations: the list of annotations assigned to the element the values are taken from U_ID

• EAttAnnDef s: the list of annotation definitions that can be assigned to the element

the values are taken from U_ID

• EAttT ype: the specified type of the element the value is taken fromU_ID

• EAtt_IsArray: whether the type of the element is also an array the value is taken fromUbool

• EAtt_{V alue}: the value of the element the value is taken fromU_base

• EAttIsEntity: whether the element is a structural entity (or a structural at-tribute)

the value is taken fromU_bool

• EAttIsDomain: whether the element is a part of a domain model the value is taken fromU_bool

Remark. TheEAtt_ID label is a globally unique identifier, while the EAtt_{N ame} label is a locally unique identifier of the element. For example, assuming that structural entities A and B both have a structural attribute C, the local identifier (EAtt_{N ame}) would be C in both cases, while the global identifiers (EAtt_ID) would be A.C and B.C. The semantics of global and local uniqueness are defined later.

Remark. The purpose of the EAtt_IsDomain label might require some clarification:

entities that are part of domain models have a value of true. Domain models are considered to be the experiments, the previously defined structure and semantics of multi-level modeling constructs are used here. Domain elements are related to non-domain elements via the EAttM eta label, meaning that domain elements are direct or indirect instances of non-domain elements.

Definition 3.2.3. Annotations are defined by annotation definitions. An an-notation definition consists of the following:

• a uniqueidentifier

• the mathematicalrangefrom which the value of an annotation is taken; values in the range consist of elements from|A|

• a mutability which defines whether the value can or cannot be different in the instance of a targeted element

• thetargeted elementsreferring to structural entities or attributes that define the elements to which the annotation can be assigned to; the target of an annotation must be a direct or indirect instance of one of the targeted elements

• anoptionality that determines if the annotation must have a value for every target or not

The nodes of the Labeled Directed Graph consist also of annotation definitions and annotations.

Remark. The definition suggests that annotations are essentially instances of anno-tation definitions. This is not technically accurate as the term instantiation refers to a different concept, but annotations are indeed based on annotation definitions and in a sense can be considered to be instances. However, annotations also have a meta element that is present in actual instantiation. For example, if annotation a is assigned to structural entity x, and annotation b is assigned to structural entity y such that y is an instance of x, then b is always an instance of a.

As an example, let us assume that an annotation definition is defined with an arbitrary ID, a range consisting of natural numbers, is mutable, has only the N ode structural entity as a targeted element, and is optional. This means that annotations based on this definition take their value from the range of natural numbers. Due to being mutable, the value can change upon instantiation. For example, in the annotation assigned node A the value could be 3, but in the annotation assigned to node B - which is an instance of A - the value could be 2. Annotations can only be assigned to N ode instances, and finally, they may not have a value at every node due to optionality. Later - when specifying the semantics of a construct - it can be defined exactly when an annotation can have a value.

The label structure used by annotation definitions is as follows, notated by AnnDefN:

• AnnDef_ID: the unique ID of the annotation definition the value is taken from UID

• AnnDef_Range: the range (consisting of a list of values) of the annotation defi-nition

the values are taken from Ubase

• AnnDef_{IsM utable}: the mutability of the annotation definition the value is taken from U_bool

• AnnDefT argeted: the list of targeted elements of the annotation definition the values are taken from U_ID

• AnnDef_IsOptional: the optionality of the annotation definition the value is taken from Ubool

According to the definition, an annotation has the following structure, notated by Ann_N:

• Ann_ID: the unique ID of the annotation the value is taken from U_ID

• AnnDef inition: the annotation definition the annotation is based on the value is taken from U_ID

• Ann_{T arget}: the concrete element the annotation is assigned to the value is taken from U_ID

• Ann_{V alue}: the value of the annotation, taken from the range of its definition the value is taken from U_base

Definition 3.2.4. The setS_EAttcontains every node of the Labeled Directed Graph conforming to the EAtt_N label structure. Similarly, the sets S_AnnDef and S_Ann

contain every node conforming to label structuresAnnDefN andAnnN respectively.

These sets will be referred to when defining the semantics of the model.

Pre-defined Nodes

In order to support the specification of arbitrary types and values - like for fields - we specify some pre-defined nodes in the graph. When specifying the nodes, we will use the following notation (the remaining labels are omitted for reasons of compactness since their values are either ∅ orundef):

EAtt{EAtt_ID, EAtt_{N ame}, EAtt_{M eta}, EAtt_IsEntity, EAtt_IsDomain}. When defining se-mantics and model validity, we will refer to these nodes, assigning semantic meaning to them.

Thebasenode (EAtt{base, base, undef, true, f alse}) is responsible for being the meta element of the following nodes representing primitive types:

• EAtt{bool, bool,base, true, f alse}

• EAtt{number, number,base, true, f alse}

• EAtt{string, string,base, true, f alse}

Semantics and Model Validity

There exist restrictions that must always apply to a stateA of the ASM, regarding the inherent behavior of structural concepts, the mechanisms of instantiation, and construct-specific semantic rules. In other words, the validity of a state of the model depends on certain criteria that must always be true. These are represented by derived functions (ΦX and ΨX), which we will soon discuss.

Definition 3.2.5. State A is invalid if any of the derived functions Φ_X for any valid input inA return f alse. Every Φ_X function returning trueis a necessary but not sufficient condition toA being valid.

Note that sufficient conditions of validity will be specified later. Next, in or-der to improve the expressive power of or-derived functions, additional constructs are introduced.

Definition 3.2.6. The select construct filters the elements in a collection based on a predicate condition. Its inputs are i) a collection and ii) a predicate condition;

its output is the collection of filtered elements. The construct iterates over every element in the collection and applies the predicate condition, returning elements to which the predicate returnstrue. The select construct uses the following notation:

select(variable:collection|predicate), where variable can of course be referred to in thepredicate.

Remark. For example,select(ad:e.EAttAnnotationDef s |ad.AnnDef_{IsM utable})filters every mutable ad annotation definition of e.

Definition 3.2.7. Theclosureconstruct collects the transitive closure of a starting element, based on a traversal expression. Its inputs are i) a starting element and ii) a traversal expression; its output is the collection of traversed elements. The construct starts with the starting element and then uses the traversal expression to traverse elements until it reaches the starting element again or until the traversal expression cannot be evaluated. Theclosure construct uses the following notation:

closure(element|expression).

Remark. For example, closure(e|XAttribute(e,0)) traverses the attribute of e at index 0, doing the same with the result and so on, until it reaches e again. It then returns the collection of traversed elements.

Definition 3.2.8. The count,min,max, avg,sum constructs serve as aggregate functions performing simple operations (count, minimum, maximum, average, sum) on a collection of elements. Its inputs are i) a collection and ii) an operating expres-sion; its output is a number resulting from the operation. The constructs iterate over every element in the collection and perform their respective operation based on the operating expression. The count construct uses the following notation, with the other constructs using a similar one: count(variable : collection | expression), where variable can of course be referred to in the expression.

Remark. For example, sum(a : e.EAtt_Attributes | a.EAtt_{V alue}) summarizes the values of every attribute of e, assuming that the attributes take their values from Unumber.

There exist derived functions in signature P

that are not a part of Φ_X or Ψ_X, instead, their purpose is to be helper functions. The following helper functions return an appropriate element from S_EAtt,S_AnnDef, or S_Ann by their ID:

EAttByID(id:U_ID) :S_EAtt=_def select(e:S_EAtt |e.EAtt_ID =id) (3.4)

AnnDef ByID(id:U_ID) :S_AnnDef =_def

select(e:SAnnDef |e.AnnDefID =id) (3.5) AnnByID(id :UID) :SAnn=def select(e:SAnn |e.AnnID =id) (3.6) The following helper functions decide if an element (EAtt) is a direct or indirect (transitive) instance of another one:

IsInstance(e:EAtt, m:EAtt) :U_bool=_def e.EAtt_{M eta}=m.EAtt_ID (3.7)

IsT ransitiveInstance(e:EAtt, m:EAtt) :Ubool =def m6=undef∧

(IsInstance(e, m)∨IsT ransitiveInstance(EAttByID(e.EAtt_{M eta}), m)) (3.8) TheAnnotationByDef function is a helper function with the purpose of return-ing an annotation (Ann) conformreturn-ing to a specified annotation definition (ad) on a specified structural entity or attribute (EAtt):

AnnotationByDef(e:EAtt, ad:AnnDef) :S_Ann =_def

select(a :e.EAttAnnotations |AnnByID(a).AnnDef inition =ad)[0] (3.9) Remark. Since Φ_A3 (specified later) defines that there cannot be multiple annota-tions conforming to the same annotation definition assigned to an element, we can be sure that there will be at most one element in the collection returned by the select construct. If the collection is empty, then indexing it will result in undef, in which case is also the return value of the function.

Before presenting the ΦX functions, let us summarize the shared and derived functions of the ASM, that can be used in the definition of Φ_X (and later, Ψ_X) functions. The following shared functions are used to access or modify the values of the EAtt, AnnDef, andAnn label structures:

• EAttN ame(id:U_ID) :U_ID

• EAttM eta(id:U_ID) :U_ID

• EAttAttribute(id:U_ID, index:U_number) :U_ID

• EAttAnnotation(id:U_ID, index:U_number) :U_ID

• EAttAnnDef(id:U_ID, index:U_number) :U_ID

• EAttT ype(id:U_ID) :U_ID

• EAttIsArray(id:U_ID) :U_bool

• EAttV alue(id :U_ID) :U_base

• EAttIsEntity(id:U_ID) :U_bool

• EAttIsDomain(id:U_ID) :U_bool

• AnnDef Range(id:U_ID, index:U_number) :U_base

• AnnDef IsM utable(id :U_ID) :U_bool

• AnnDef T argeted(id:U_ID, index:U_number) :U_ID

• AnnDef IsOptional(id:U_ID) :U_bool

• AnnDef inition(id:U_ID) :U_ID

• AnnT arget(id :U_ID) :U_ID

• AnnV alue(id:U_ID) :U_base

The following are the helper (derived) functions of the ASM that are always available as they are pre-defined:

• EAttByID(id:U_ID) :S_EAtt

• AnnDef ByID(id:U_ID) :S_AnnDef

• AnnByID(id:U_ID) :S_Ann

• IsInstance(e:EAtt, m:EAtt) :U_bool

• IsT ransitiveInstance(e:EAtt, m:EAtt) :U_bool

• AnnotationByDef(e:EAtt, ad:AnnDef) :S_Ann

Finally, the following constructs that are used to extend the expressive power of the formalism are also available for use:

• select(variable:collection|predicate)

• closure(element|expression)

• count(variable:collection |expression)

• min(variable:collection |expression)

• max(variable:collection|expression)

• avg(variable:collection|expression)

• sum(variable:collection|expression)

In the following, we present the Φ_X derived functions that are always a part of signature P

of the ASM. According to the definition, return values are all taken fromU_bool. First, the semantics of global and local uniqueness are specified. Every EAtt, AnnDef, and Ann label structure must have a globally unique identifier (EAtt_ID, AnnDef_ID, Ann_ID):

Φ_GlobalEA(g :EAtt) =_def (@e∈S_EAtt:e6=g∧g.EAtt_ID =e.EAtt_ID)∧

(@ad∈S_AnnDef :ad6=g∧g.EAtt_ID=ad.AnnDef_ID)∧

(@a∈S_Ann :a6=g∧g.EAtt_ID =a.Ann_ID) (3.10)

ΦGlobalAD(g :AnnDef) =def (@e∈SEAtt :e6=g∧g.AnnDefID =e.EAttID)∧

(@ad∈S_AnnDef :ad 6=g∧g.AnnDef_ID =ad.AnnDef_ID)∧

(@a∈S_Ann :a6=g∧g.AnnDef_ID =a.Ann_ID) (3.11) Φ_GlobalA(g :Ann) =_def (@e∈S_EAtt:e6=g∧g.Ann_ID =e.EAtt_ID)∧

(@ad∈S_AnnDef :ad 6=g∧g.Ann_ID =ad.AnnDef_ID)∧

(@a ∈S_Ann :a6=g∧g.Ann_ID =a.Ann_ID) (3.12) The elements in theEAttAttributes label must always be locally unique:

ΦLocal(e:EAtt) =def ∀a ∈e.EAttAttributes :@a2∈e.EAttAttributes :

a26=a∧EAttByID(a).EAtt_{N ame} =EAttByID(a2).EAtt_{N ame} (3.13) Since self meta references are usually not allowed in modeling, they are forbidden:

Φ_{Self M eta}(e:EAtt) =_def e.EAtt_{M eta}6=e.EAtt_ID (3.14) The EAtt_{T ype}, EAtt_IsArray and EAtt_{V alue} labels cannot be interpreted on struc-tural entities, as opposed to strucstruc-tural attributes:

Φ_Entity(e :EAtt) =_def e.EAtt_IsEntity =⇒

e.EAtt_{T ype} =undef ∧e.EAtt_IsArray =undef ∧e.EAtt_{V alue}=undef (3.15) Φ_Attribute1(e:EAtt) =_def ¬e.EAtt_IsEntity =⇒

e.EAtt_{T ype}6=undef ∧e.EAtt_IsArray 6=undef (3.16) The EAttV alue label is only interpreted on domain attributes that are not com-plex (Φ_Attribute2 and Φ_Attribute3). Moreover, only domain attributes can be complex attributes (Φ_Attribute4 and Φ_Attribute5):

Φ_Attribute2(e:EAtt) =_def ¬e.EAtt_IsEntity∧ ¬e.EAtt_IsDomain =⇒

e.EAtt_{V alue}=undef (3.17) Φ_Attribute3(e:EAtt) =_def ¬e.EAtt_IsEntity∧e.EAtt_IsDomain∧ ¬e.EAtt_IsArray =⇒

e.EAtt_{V alue}6=undef (3.18) Φ_Attribute4(e:EAtt) =_def ¬e.EAtt_IsEntity∧ ¬e.EAtt_IsDomain =⇒

e.EAtt_Attributes =∅ (3.19) Φ_Attribute5(e:EAtt) =_def e.EAtt_IsArray∧e.EAtt_IsDomain =⇒

e.EAtt_Attributes 6=∅ (3.20) Annotations (EAttAnnotations) can only be assigned to entities or attributes with EAtt_IsDomain =true:

Φ_DomainA(e:EAtt) =_def ¬e.EAtt_IsDomain =⇒ e.EAttAnnotations =∅ (3.21)

Attributes have to conform to the meta hierarchy, namely, for every attribute in the meta element, an instance attribute must be present in the attributes of the instance element:

ΦAttributeM eta(e:EAtt) =_def e.EAtt_{M eta}6=undef =⇒

∀a ∈EAttByID(e.EAtt_{M eta}).EAtt_Attributes :

∃a2∈e.EAttAttributes :a2.EAttM eta =a (3.22) If the structural meta type of a structural attribute is not an array (EAttIsArray), then the attributes of the element must be empty. Also note that due to Φ_Attribute3, only domain attributes can actually contain other attributes:

Φ_Array1(e :EAtt) =_def e.EAtt_{M eta} 6=undef∧

¬EAttByID(e.EAttM eta).EAttIsArray =⇒ e.EAttAttributes =∅ (3.23) The array nature of a structural attribute cannot be broken in an instantiation chain; if the meta attribute is an array, then the instance must be an array as well:

ΦArray2(e :EAtt) =def e.EAttM eta 6=undef∧

EAttByID(e.EAtt_{M eta}).EAtt_IsArray =⇒ e.EAtt_IsArray (3.24) Certain labels are not allowed to haveundef as a value, but since every universe of |A|contains undef by definition, these labels have to be constrained:

Φ_{U ndef EA}(e:EAtt) =_def e.EAtt_ID 6=undef ∧e.EAtt_{N ame} 6=undef∧

e.EAtt_IsEntity 6=undef ∧e.EAtt_IsDomain 6=undef (3.25) Φ_{U ndef AD}(ad:AnnDef) =_def ad.AnnDef_ID 6=undef∧

ad.AnnDef_{IsM utable} 6=undef ∧ad.AnnDef_IsOptional 6=undef (3.26) Φ_{U ndef A}(a:Ann) =_def a.Ann_ID 6=undef ∧a.AnnDef inition 6=undef

∧a.Ann_{T arget} 6=undef (3.27) Remark. The value (Ann_{V alue}) of an annotation can beundef since optional anno-tations may not always have a value. Labels consisting of a collection of values (e.g., EAttAnnotations) cannot have undef as their value due to the nature of collections.

Instead, they can take the value of ∅.

The following Φ_X functions further constraint the set of IDs certain labels can take their value(s) from in order to be semantically accurate:

Φ_ID1(e:EAtt) =_def e.EAtt_{M eta} 6=undef =⇒

∃m ∈SEAtt :m.EAttID =e.EAttM eta (3.28) ΦID2(e:EAtt) =def ∀a∈e.EAttAttributes :∃e2∈SEAtt :e2.EAttID =a (3.29) Φ_ID3(e:EAtt) =_def ∀a ∈e.EAttAnnotations :

∃ad∈S_AnnDef :ad.AnnDef_ID =a (3.30)

ΦID4(ad:AnnDef) =def ∀a∈ad.AnnDefT argeted :

∃e∈S_EAtt :e.EAtt_ID=a (3.31) ΦID5(a:Ann) =def ∃ad∈SAnnDef :ad.AnnDefID =a.AnnDef inition (3.32) ΦID6(a:Ann) =def ∃e∈SEAtt:e.EAttID =a.AnnT arget (3.33) The following ΦX functions deal with annotations and annotation definitions.

Φ_A1 defines that an annotation must be present in the EAttAnnotations label of its target and that EAtt_IsDomain must always be true for the target:

Φ_A1(a :Ann) =_def a∈EAttByID(a.Ann_{T arget}).EAttAnnotations∧

EAttByID(a.AnnT arget).EAttIsDomain (3.34) The target of an assigned annotation must be a transitive instance of at least one of the targeted elements of the associated annotation definition:

ΦA2(a :Ann) =def ∃e∈AnnDef ByID(a.AnnDef inition).AnnDefT argeted :

IsT ransitiveInstance(EAttByID(a.Ann_{T arget}), EAttByID(e)) (3.35) There must not be multiple annotations with the same annotation definition assigned to the same target (e.g., there cannot be two ”potency” annotations on the same structural entity or attribute):

Φ_A3(a :Ann) =_def @a2∈EAttByID(a.Ann_{T arget}).EAttAnnotations :

a26=a.AnnID∧a.AnnDef inition =AnnByID(a2).AnnDef inition (3.36) The value of an annotation must be taken from the range of the associated annotation definition:

Φ_A4(a :Ann) =_def a.Ann_{V alue} ∈

AnnDef ByID(a.AnnDef inition).AnnDef_Range (3.37) If an annotation is not optional (mandatory), then it must always have a value other thanundef (Φ_A5). Moreover, a mandatory annotation must always be present in the EAttAnnotations label of its targeted elements (Φ_A6):

ΦA5(a :Ann) =def ¬AnnDef ByID(a.AnnDef inition).AnnDefIsOptional =⇒

a.Ann_{V alue}6=undef (3.38) Φ_A6(a :Ann) =_def ¬AnnDef ByID(a.AnnDef inition).AnnDef_IsOptional =⇒

∀t∈AnnDef ByID(a.AnnDef inition).AnnDefT argeted :∀e∈SEAtt:e.EAttIsDomain∧ IsT ransitiveInstance(e, EAttByID(t)) =⇒ a.Ann_ID ∈e.EAttAnnotations (3.39) If an annotation is immutable, then its value must always be equal to the value of the annotation of the meta element of the target:

Φ_A7(a :Ann) =_def ¬AnnDef ByID(a.AnnDef inition).AnnDef_{IsM utable}∧

AnnotationByDef(EAttByID(a.Ann_{T arget}).EAtt_{M eta}, a.AnnDef inition)6=undef

=⇒ a.Ann_{V alue}=AnnotationByDef(EAttByID(a.Ann_{T arget}).EAtt_{M eta}, a.AnnDef inition).Ann_{V alue} (3.40)

An annotation definition must be present in theEAttAnnDef s label of its target:

Φ_A8(ad:AnnDef) =_def ∀t∈ad.AnnDef_{T argeted} :

ad∈EAttByID(t).EAtt_{AnnDef s} (3.41) The annotation definitions of the meta element must also be present in the annotation definitions of the instance element:

Φ_A9(e:EAtt) =_def e.EAtt_{M eta}6=undef =⇒

∀ad∈EAttByID(e.EAttM eta).EAttAnnDef s :ad∈e.EAttAnnDef s (3.42) The following Φ_X functions define the built-in primitive types a structural tribute can have, in correlation with the relevant universes (e.g., a structural at-tribute with a type ofbool must have a value taken from U_bool):

ΦT ypeBool(e:EAtt) =def e.EAttT ype =bool∧e.EAttIsDomain =⇒

e.EAtt_{V alue}∈U_bool (3.43)

ΦT ypeString(e:EAtt) =_def e.EAtt_{T ype}=string∧e.EAtt_IsDomain =⇒

e.EAtt_{V alue} ∈U_string (3.44)

ΦT ypeN umber(e :EAtt) =_def e.EAtt_{T ype} =number∧e.EAtt_IsDomain =⇒

e.EAtt_{V alue}∈U_number (3.45) IfEAttT ype is not a primitive type, then both the type and value must refer to a valid identifier and the value must be a transitive instance of the type. For example, if the type is N ode, then there must be a structural entity or attribute with the ID N odeand EAttV alue must be a transitive instance of N ode:

Φ_{T ypeID}(e:EAtt) =_def e.EAtt_{T ype} ∈ {bool, number, string, base}∧/

e.EAtt_IsDomain =⇒ ∃e2∈S_EAtt :e2.EAtt_ID =e.EAtt_{T ype}∧ ∃e3∈S_EAtt: e3.EAtt_ID =e.EAtt_{V alue}∧

IsT ransitiveInstance(EAttByID(e.EAtt_{V alue}), EAttByID(e.EAtt_{T ype})) (3.46) The ”base” type imposes no restrictions, meaning that the value of the attribute comes from U_base. Note that Ψ_X functions can still introduce restrictions on at-tributes with the ”base” type.

Instantiation in our approach is aimed to be as flexible as possible in order to be able to specify different interpretations in the literature. Every element must have exactly one meta element. Rules constraining instantiation can be added by specifying Ψ_X derived functions that describe the semantics of a particular construct.

These functions can constrain the process of instantiation and introduce semantics to the model. Thus, specifying a construct with the formalism consists of two steps:

i) defining the structure - labeled nodes in the graph; and ii) defining the semantics - the Ψ_X functions that can also refer to the newly defined structure.

Definition 3.2.9. State Aof the ASM is validif and only if all of the ΦX and ΨX

derived functions return true for all valid input in A.

Definition 3.2.10. A domain model consists of i) structural entities and at-tributes (EAtt) with EAtt_Domain =true and ii) annotations (Ann). Ψ_X functions are only evaluated on domain models. Domain models are considered to be the scientific experiments in our approach.

Remark. In the Φ_X functions, we often differentiated between domain entities and attributes (based on the value of EAtt_IsDomain) in order to constrain domain models.

In theΨ_X functions, this differentiation is not necessary as they are only interpreted over domain models. This means that the semantics of a multi-level construct are enforced only in the actual experiments, it is not possible to alter the underlying semantics of the formalism specified by the Φ_X functions.

In document Ph.D.DissertationFerencAttilaSomogyiAdvisor:GergelyMezei,Ph.D.AssociateProfessor INVESTIGATINGTEXT-BASEDDOMAIN-SPECIFICMODELINGTECHNIQUESSZ¨OVEGALAP´USZAKTER¨ULETIMODELLEZ´ESIM´ODSZEREKVIZSG´ALATA (Pldal 72-82)