ISO 10303-214:2010(E)

5.2.4 automotive_design rule definitions

5.2.4.1 application_protocol_definition_required

The application_protocol_definition_required rule ensures that at least one application_protocol_definition is specified that provides the designator 'automotive_design' of this application protocol.
*)
RULE application_protocol_definition_required FOR
    (application_context);
WHERE
  WR1:  SIZEOF( QUERY( ac <* application_context |
              (SIZEOF (QUERY (apd <* USEDIN(ac,'AUTOMOTIVE_DESIGN.APPLICATION_PROTOCOL_DEFINITION.APPLICATION') |
                apd.application_interpreted_model_schema_name = 'automotive_design'
                )) > 0)
              )) > 0;   
END_RULE;
(*

Argument definitions:

application_context: the set of all instances of application_context.

Formal propositions

WR1: At least one instance of application_context shall be refered by one instance of application_protocol_definition which contains the instance of application_context as its application attribute and has a application_interpreted_model_schema_name of 'automotive_design'.

5.2.4.2 approval_person_organization_requires_date_time

The approval_person_organization_requires_date_time rule specifies that each instance of approval_person_organization shall be referenced by exactly one of either applied_date_assignment or applied_date_and_time_assignment where the assigned date or date and time specifies the sign off date of the approval. This rule enforces the requirement for every Approval, that in case the approving person or organization is specified, also the sign off date of the Approval has to be given.
*)
RULE approval_person_organization_requires_date_time FOR
    (approval_person_organization);
WHERE
  WR1:  SIZEOF( QUERY( apo <* approval_person_organization |
        	 (SIZEOF( QUERY( u <* USEDIN( apo, 'AUTOMOTIVE_DESIGN.' +
        		    'APPLIED_DATE_ASSIGNMENT.ITEMS') | 
        	    (u.role.name = 'sign off') )) +
          	  SIZEOF( QUERY( u <* USEDIN( apo, 'AUTOMOTIVE_DESIGN.' +
        	 	    'APPLIED_DATE_AND_TIME_ASSIGNMENT.ITEMS') | 
        	    (u.role.name = 'sign off')) 
        	   )) <> 1
              )) = 0;
           
END_RULE;
(*

Argument definitions:

approval_person_organization: the set of all instances of approval_person_organization.

Formal propositions

WR1: There shall be exactly one instance of either applied_date_assignment or applied_date_and_time_assignment associated to an approval_person_organization where the name of date_role / date_time_role is 'sign off'.

5.2.4.3 approval_requires_approval_assignment

The approval_requires_approval_assignment rule specifies that each instance of approval is referenced by at least one instance of approval_assignment as the assigned_approval. This rule enforces the requirement for every approval to be applied at least once.
*)
RULE approval_requires_approval_assignment FOR
    (approval);
WHERE
  WR1:  SIZEOF( QUERY( a <* approval |
               SIZEOF( USEDIN( a, 'AUTOMOTIVE_DESIGN.APPROVAL_ASSIGNMENT.ASSIGNED_APPROVAL')
                ) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

approval: the set of all instances of approval.

Formal propositions

WR1: Each instance of approval shall be referenced at least once as the assigned_approval by an instance of approval_assignment.

5.2.4.4 complex_product_requires_product_definition

The complex_product_requires_product_definition rule ensures that each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'functionality', 'conceptual product', or 'alternative solution', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'functional definition', 'conceptual definition', or 'alternative definition', respectively.
*)
RULE complex_product_requires_product_definition FOR
    (product_definition,
     product_definition_formation,
     product_related_product_category);
WHERE
  WR1:  SIZEOF( QUERY( pdf <* product_definition_formation |
               ((SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'functionality')) = 1) AND
               (SIZEOF( QUERY( pd <* USEDIN(pdf,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION.FORMATION') |
                  pd.frame_of_reference.name = 'functional definition')) <> 1))
                  OR
                 ((SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'conceptual design')) = 1) AND
               (SIZEOF( QUERY( pd <* USEDIN(pdf,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION.FORMATION') |
                  pd.frame_of_reference.name = 'conceptual definition')) <> 1))
                  OR
                 ((SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'alternative solution')) = 1) AND
               (SIZEOF( QUERY( pd <* USEDIN(pdf,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION.FORMATION') |
                  pd.frame_of_reference.name = 'alternative definition')) <> 1))))=0;
                  
END_RULE;
(*

Argument definitions:

product_definition: the set bof all instances of product_definition.

product_definition_formation: the set bof all instances of product_definition_formation.

product_related_product_category: the set bof all instances of product_related_product_category.

Formal propositions

WR1: Each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'functionality', 'conceptual definition', or 'alternative solution', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'functional definition', 'conceptual definition', or 'alternative definition', respectively.

5.2.4.5 compound_features_of_equal_type

The compound_features_of_equal_type rule ensures that each instance of shape_aspect_relationship relates compound features of equal type, i.e. that panel features and solid features are not mixed.
*)
RULE compound_features_of_equal_type FOR
    (compound_feature,
     shape_aspect_relationship);
WHERE
  WR1:  SIZEOF( QUERY( sar <* shape_aspect_relationship |
                 (sar.name = 'compound feature ordering') AND(
                 (SIZEOF( QUERY( fcr <* USEDIN(sar.relating_shape_aspect,
                          'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_RELATIONSHIP.RELATED_SHAPE_ASPECT') |
                    ('AUTOMOTIVE_DESIGN.FEATURE_COMPONENT_RELATIONSHIP' IN
                     TYPEOF(fcr)) AND
                    ('AUTOMOTIVE_DESIGN.COMPOSITE_SHAPE_ASPECT' IN
                     TYPEOF(fcr.relating_shape_aspect)) AND
                    (fcr.relating_shape_aspect.name IN 
                     ['compound feature in solid','compound feature in panel']))) = 0) AND 
                  (SIZEOF( QUERY( fcr <* USEDIN(sar.related_shape_aspect,
                           'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_RELATIONSHIP.RELATED_SHAPE_ASPECT') |
                     ('AUTOMOTIVE_DESIGN.FEATURE_COMPONENT_RELATIONSHIP' IN
                      TYPEOF(fcr)) AND
                     ('AUTOMOTIVE_DESIGN.COMPOSITE_SHAPE_ASPECT' IN
                      TYPEOF(fcr.relating_shape_aspect)) AND
                     (fcr.relating_shape_aspect.name IN 
                      ['compound feature in solid','compound feature in panel']))) = 0))
                  )) = 0;
          
END_RULE;
(*

Argument definitions:

compound_feature: the set of all instances of compound_feature.

shape_aspect_relationship: the set of all instances of shape_aspect_relationship.

Formal propositions

WR1: For each instance of shape_aspect_relationship that has a name of 'compound feature ordering', the relating_shape_aspect and the related_shape_aspect shall be both related_shape_aspect in a feature_component_relationship that refer as relating_shape_aspect to a composite_shape_aspect that has a name of either 'compound feature in solid' or 'compound feature in panel'.

5.2.4.6 consistent_uncertainty

The consistent_uncertainty rule specifies that any instance of global_uncertainty_assigned_context or uncertainty_assigned_representation shall not contain two instances of uncertainty_measure_with_unit with the same name in their respective uncertainty set. It also specifies that any qualified_representation_item shall not have any two instances of uncertainty_qualifier with the same measure_name in its set of qualifiers.
*)
RULE consistent_uncertainty FOR
    (global_uncertainty_assigned_context,
     qualified_representation_item,
     uncertainty_assigned_representation);
WHERE
  WR1:  
SIZEOF ( QUERY ( guac <*
             global_uncertainty_assigned_context | SIZEOF ( QUERY ( u1
             <* guac. uncertainty | SIZEOF ( QUERY ( u2 <* guac.
             uncertainty | u2. name =u1. name ) ) >
 1 ) ) >0 )) =0 ; 
           
  WR2:  SIZEOF( QUERY( uar <* uncertainty_assigned_representation |
               SIZEOF( QUERY( u1 <* uar.uncertainty |
                 SIZEOF( QUERY( u2 <* uar.uncertainty |
                   u2.name = u1.name
                  )) > 0
                )) > 0
              )) = 0;
           
  WR3:  SIZEOF( QUERY( qri <* qualified_representation_item |
               SIZEOF( QUERY( u1 <* qri.qualifiers |
                 ('AUTOMOTIVE_DESIGN.UNCERTAINTY_QUALIFIER' IN
                  TYPEOF(u1)) AND
                 (SIZEOF( QUERY( u2 <* qri.qualifiers |
                    ('AUTOMOTIVE_DESIGN.UNCERTAINTY_QUALIFIER' IN
                     TYPEOF(u2)) AND
                    (u2\uncertainty_qualifier.measure_name = 
                     u1\uncertainty_qualifier.measure_name)
                   )) > 0)
                )) > 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

global_uncertainty_assigned_context: the set of all instances opf global_uncertainty_assigned_context.

qualified_representation_item: the set of all instances of qualified_representation_item.

uncertainty_assigned_representation: the set of all instances of uncertainty_assigned_representation.

qualified_representation_item: the set of all instances of qualified_representation_item.

uncertainty_assigned_representation: the set of all instances of uncertainty_assigned_representation.

Formal propositions

WR1: Each instance of global_uncertainty_assigned_context shall not contain two instances of uncertainty_measure_with_unit with the same name in its uncertainty set.

WR2: Each instance of uncertainty_assigned_representation shall not contain two instances of uncertainty_measure_with_unit with the same name in its uncertainty set.

WR3: Each instance of qualified_representation_item shall not have any two instances of uncertainty_qualifier with the same measure_name in its set of qualifiers.

5.2.4.7 coordinated_assembly_and_shape

The coordinated_assembly_and_shape rule specifies that the relationship between two product_definition entities which are an assembly and a component in a next_assembly_usage_occurrence and the relationship between two shape_representation entities which contain the representation of the shapes of the assembly and the component in a shape_representation_relationship must be explicitly related through the context_dependent_shape_representation. This rule calls the function assembly_shape_is_defined which returns true if the assembly relationship and shape relationship are explicitly related.
*)
RULE coordinated_assembly_and_shape FOR
    (next_assembly_usage_occurrence);
WHERE
  WR1:  SIZEOF (QUERY (nauo <* next_assembly_usage_occurrence |
        NOT (assembly_shape_is_defined (nauo)))) = 0;   
END_RULE;
(*

Argument definitions:

next_assembly_usage_occurrence: the set of all instances of next_assembly_usage_occurrence.

Formal propositions

WR1: For each instance of next_assembly_usage_occurrence, the assembly_shape_is_defined function shall be true.

5.2.4.8 curve_font_usage

The curve_font_usage rule ensures that each curve_style_font, pre_defined_curve_font, and externally_defined_curve_font shall define the curve font of at least one curve_style.
*)
RULE curve_font_usage FOR
    (curve_style_font,
     externally_defined_curve_font,
     pre_defined_curve_font);
WHERE
  WR1:  SIZEOF (QUERY (csf <* curve_style_font |
              (SIZEOF (USEDIN (csf, 'AUTOMOTIVE_DESIGN.CURVE_STYLE.CURVE_FONT')
                ) = 0)
              )) = 0;   
  WR2:  SIZEOF (QUERY (pdcf <* pre_defined_curve_font |
              (SIZEOF (USEDIN (pdcf, 'AUTOMOTIVE_DESIGN.CURVE_STYLE.CURVE_FONT')
               ) = 0)
              )) = 0;   
  WR3:  SIZEOF (QUERY (edcf <* externally_defined_curve_font |
               NOT (SIZEOF (USEDIN (edcf, 'AUTOMOTIVE_DESIGN.' +
                                          'CURVE_STYLE.CURVE_FONT'))>=1)))=0;   
END_RULE;
(*

Argument definitions:

curve_style_font: the set of all instances of curve_style_font.

externally_defined_curve_font: the set of all instances of externally_defined_curve_font.

pre_defined_curve_font: the set of all instances of pre_defined_curve_font.

externally_defined_curve_font: the set of all instances of externally_defined_curve_font.

pre_defined_curve_font: the set of all instances of pre_defined_curve_font.

Formal propositions

WR1: Each curve_style_font shall participate in the definition of at least one curve_style.

WR2: Each pre_defined_curve_font shall participate in the definition of at least one curve_style.

WR3: Each externally_defined_curve_font shall participate in the definition of at least one curve_style.

5.2.4.9 dependent_instantiable_action_directive

The dependent_instantiable_action_directive rule specifies that each instance of action_directive is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_action_directive FOR
    (action_directive);
WHERE
  WR1:  SIZEOF ( QUERY (a <* action_directive |
        NOT (SIZEOF (USEDIN (a,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

action_directive: the set of all instances of action_directive.

Formal propositions

WR1: For each instance of action_directive, there shall be a reference to the action_directive instance from an attribute of another entity.

5.2.4.10 dependent_instantiable_action_resource_type

The dependent_instantiable_action_resource_type rule specifies that each instance of action_resource_type is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_action_resource_type FOR
    (action_resource_type);
WHERE
  WR1:  SIZEOF ( QUERY (a <* action_resource_type |
        NOT (SIZEOF (USEDIN (a,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

action_resource_type: the set of all instances of action_resource_type.

Formal propositions

WR1: For each instance of action_resource_type, there shall be a reference to the action_resource_type instance from an attribute of another entity.

5.2.4.11 dependent_instantiable_approval_role

The dependent_instantiable_approval_role rule specifies that each instance of approval_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_approval_role FOR
    (approval_role);
WHERE
  WR1:  SIZEOF ( QUERY (a <* approval_role |
        NOT (SIZEOF (USEDIN (a,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

approval_role: the set of all instances of approval_role.

Formal propositions

WR1: For each instance of approval_role, there shall be a reference to the approval_role instance from an attribute of another entity.

5.2.4.12 dependent_instantiable_attribute_value_role

The dependent_instantiable_attribute_value_role rule specifies that each instance of attribute_value_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_attribute_value_role FOR
    (attribute_value_role);
WHERE
  WR1:  SIZEOF ( QUERY (a <* attribute_value_role |
        NOT (SIZEOF (USEDIN (a,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

attribute_value_role: the set of all instances of attribute_value_role.

Formal propositions

WR1: For each instance of attribute_value_role, there shall be a reference to the attribute_value_role instance from an attribute of another entity.

5.2.4.13 dependent_instantiable_classification_role

The dependent_instantiable_classification_role rule specifies that each instance of classification_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_classification_role FOR
    (classification_role);
WHERE
  WR1:  SIZEOF ( QUERY (c <* classification_role |
        NOT (SIZEOF (USEDIN (c,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

classification_role: the set of all instances of classification_role.

Formal propositions

WR1: For each instance of classification_role, there shall be a reference to the classification_role instance from an attribute of another entity.

5.2.4.14 dependent_instantiable_colour_rgb

The dependent_instantiable_colour_rgb rule specifies that each instance of colour_rgb is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_colour_rgb FOR
    (colour_rgb);
WHERE
  WR1:  SIZEOF ( QUERY (c <* colour_rgb |
        NOT (SIZEOF (USEDIN (c,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

colour_rgb: the set of all instances of colour_rgb.

Formal propositions

WR1: For each instance of colour_rgb, there shall be a reference to the colour_rgb instance from an attribute of another entity.

5.2.4.15 dependent_instantiable_contract_type

The dependent_instantiable_contract_type rule specifies that each instance of contract_type is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_contract_type FOR
    (contract_type);
WHERE
  WR1:  SIZEOF ( QUERY (c <* contract_type |
        NOT (SIZEOF (USEDIN (c,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

contract_type: the set of all instances of contract_type.

Formal propositions

WR1: For each instance of contract_type, there shall be a reference to the contract_type instance from an attribute of another entity.

5.2.4.16 dependent_instantiable_curve_style

The dependent_instantiable_curve_style rule specifies that each instance of curve_style is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_curve_style FOR
    (curve_style);
WHERE
  WR1:  SIZEOF ( QUERY (c <* curve_style |
        NOT (SIZEOF (USEDIN (c,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

curve_style: the set of all instances of curve_style.

Formal propositions

WR1: For each instance of curve_style, there shall be a reference to the curve_style instance from an attribute of another entity.

5.2.4.17 dependent_instantiable_date

The dependent_instantiable_date rule specifies that each instance of date is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_date FOR
    (date);
WHERE
  WR1:  SIZEOF ( QUERY (d <* date |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

date: the set of all instances of date.

Formal propositions

WR1: For each instance of date, there shall be a reference to the date instance from an attribute of another entity.

5.2.4.18 dependent_instantiable_date_and_time

The dependent_instantiable_date_and_time rule specifies that each instance of date_and_time is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_date_and_time FOR
    (date_and_time);
WHERE
  WR1:  SIZEOF ( QUERY (d <* date_and_time |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

date_and_time: the set of all instances of date_and_time.

Formal propositions

WR1: For each instance of date_and_time, there shall be a reference to the date_and_time instance from an attribute of another entity.

5.2.4.19 dependent_instantiable_date_role

The dependent_instantiable_date_role rule specifies that each instance of date_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_date_role FOR
    (date_role);
WHERE
  WR1:  SIZEOF ( QUERY (d <* date_role |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

date_role: the set of all instances of date_role.

Formal propositions

WR1: For each instance of date_role, there shall be a reference to the date_role instance from an attribute of another entity.

5.2.4.20 dependent_instantiable_date_time_role

The dependent_instantiable_date_time_role rule specifies that each instance of date_time_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_date_time_role FOR
    (date_time_role);
WHERE
  WR1:  SIZEOF ( QUERY (d <* date_time_role |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

date_time_role: the set of all instances of date_time_role.

Formal propositions

WR1: For each instance of date_time_role, there shall be a reference to the date_time_role instance from an attribute of another entity.

5.2.4.21 dependent_instantiable_derived_unit

The dependent_instantiable_derived_unit rule specifies that each instance of derived_unit is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_derived_unit FOR
    (derived_unit);
WHERE
  WR1:  SIZEOF ( QUERY (d <* derived_unit |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

derived_unit: the set of all instances of derived_unit.

Formal propositions

WR1: For each instance of derived_unit, there shall be a reference to the derived_unit instance from an attribute of another entity.

5.2.4.22 dependent_instantiable_dimensional_size

The dependent_instantiable_dimensional_size rule specifies that each instance of dimensional_size is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_dimensional_size FOR
    (dimensional_size);
WHERE
  WR1:  SIZEOF ( QUERY (d <* dimensional_size |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

dimensional_size: the set of all instances of dimensional_size.

Formal propositions

WR1: For each instance of dimensional_size, there shall be a reference to the dimensional_size instance from an attribute of another entity.

5.2.4.23 dependent_instantiable_document_usage_role

The dependent_instantiable_document_usage_role rule specifies that each instance of document_usage_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_document_usage_role FOR
    (document_usage_role);
WHERE
  WR1:  SIZEOF ( QUERY (d <* document_usage_role |
        NOT (SIZEOF (USEDIN (d,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

document_usage_role: the set of all instances of document_usage_role.

Formal propositions

WR1: For each instance of document_usage_role, there shall be a reference to the document_usage_role instance from an attribute of another entity.

5.2.4.24 dependent_instantiable_effectivity_context_role

The dependent_instantiable_effectivity_context_role rule specifies that each instance of effectivity_context_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_effectivity_context_role FOR
    (effectivity_context_role);
WHERE
  WR1:  SIZEOF ( QUERY (e <* effectivity_context_role |
        NOT (SIZEOF (USEDIN (e,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

effectivity_context_role: the set of all instances of effectivity_context_role.

Formal propositions

WR1: For each instance of effectivity_context_role, there shall be a reference to the effectivity_context_role instance from an attribute of another entity.

5.2.4.25 dependent_instantiable_event_occurrence_role

The dependent_instantiable_event_occurrence_role rule specifies that each instance of event_occurrence_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_event_occurrence_role FOR
    (event_occurrence_role);
WHERE
  WR1:  SIZEOF ( QUERY (e <* event_occurrence_role |
        NOT (SIZEOF (USEDIN (e,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

event_occurrence_role: the set of all instances of event_occurrence_role.

Formal propositions

WR1: For each instance of event_occurrence_role, there shall be a reference to the event_occurrence_role instance from an attribute of another entity.

5.2.4.26 dependent_instantiable_externally_defined_symbol

The dependent_instantiable_externally_defined_symbol rule specifies that each instance of externally_defined_symbol is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_externally_defined_symbol FOR
    (externally_defined_symbol);
WHERE
  WR1:  SIZEOF ( QUERY (e <* externally_defined_symbol |
        NOT (SIZEOF (USEDIN (e,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

externally_defined_symbol: the set of all instances of externally_defined_symbol.

Formal propositions

WR1: For each instance of externally_defined_symbol, there shall be a reference to the externally_defined_symbol instance from an attribute of another entity.

5.2.4.27 dependent_instantiable_fill_area_style

The dependent_instantiable_fill_area_style rule specifies that each instance of fill_area_style is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_fill_area_style FOR
    (fill_area_style);
WHERE
  WR1:  SIZEOF ( QUERY (f <* fill_area_style |
        NOT (SIZEOF (USEDIN (f,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

fill_area_style: the set of all instances of fill_area_style.

Formal propositions

WR1: For each instance of fill_area_style, there shall be a reference to the fill_area_style instance from an attribute of another entity.

5.2.4.28 dependent_instantiable_fill_area_style_colour

The dependent_instantiable_fill_area_style_colour rule specifies that each instance of fill_area_style_colour is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_fill_area_style_colour FOR
    (fill_area_style_colour);
WHERE
  WR1:  SIZEOF ( QUERY (f <* fill_area_style_colour |
        NOT (SIZEOF (USEDIN (f,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

fill_area_style_colour: the set of all instances of fill_area_style_colour.

Formal propositions

WR1: For each instance of fill_area_style_colour, there shall be a reference to the fill_area_style_colour instance from an attribute of another entity.

5.2.4.29 dependent_instantiable_identification_role

The dependent_instantiable_identification_role rule specifies that each instance of identification_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_identification_role FOR
    (identification_role);
WHERE
  WR1:  SIZEOF ( QUERY (i <* identification_role |
        NOT (SIZEOF (USEDIN (i,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

identification_role: the set of all instances of identification_role.

Formal propositions

WR1: For each instance of identification_role, there shall be a reference to the identification_role instance from an attribute of another entity.

5.2.4.30 dependent_instantiable_measure_with_unit

The dependent_instantiable_measure_with_unit rule specifies that each instance of measure_with_unit is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_measure_with_unit FOR
    (measure_with_unit);
WHERE
  WR1:  SIZEOF ( QUERY (m <* measure_with_unit |
        NOT (SIZEOF (USEDIN (m,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

measure_with_unit: the set of all instances of measure_with_unit.

Formal propositions

WR1: For each instance of measure_with_unit, there shall be a reference to the measure_with_unit instance from an attribute of another entity.

5.2.4.31 dependent_instantiable_named_unit

The dependent_instantiable_named_unit rule specifies that each instance of named_unit is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_named_unit FOR
    (named_unit);
WHERE
  WR1:  SIZEOF ( QUERY (n <* named_unit |
        NOT (SIZEOF (USEDIN (n,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

named_unit: the set of all instances of named_unit.

Formal propositions

WR1: For each instance of named_unit, there shall be a reference to the named_unit instance from an attribute of another entity.

5.2.4.32 dependent_instantiable_object_role

The dependent_instantiable_object_role rule specifies that each instance of object_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_object_role FOR
    (object_role);
WHERE
  WR1:  SIZEOF ( QUERY (o <* object_role |
        NOT (SIZEOF (USEDIN (o,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

object_role: the set of all instances of object_role.

Formal propositions

WR1: For each instance of object_role, there shall be a reference to the object_role instance from an attribute of another entity.

5.2.4.33 dependent_instantiable_organization_role

The dependent_instantiable_organization_role rule specifies that each instance of organization_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_organization_role FOR
    (organization_role);
WHERE
  WR1:  SIZEOF ( QUERY (o <* organization_role |
        NOT (SIZEOF (USEDIN (o,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

organization_role: the set of all instances of organization_role.

Formal propositions

WR1: For each instance of organization_role, there shall be a reference to the organization_role instance from an attribute of another entity.

5.2.4.34 dependent_instantiable_organizational_project_role

The dependent_instantiable_organizational_project_role rule specifies that each instance of organizational_project_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_organizational_project_role FOR
    (organizational_project_role);
WHERE
  WR1:  SIZEOF ( QUERY (o <* organizational_project_role |
        NOT (SIZEOF (USEDIN (o,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

organizational_project_role: the set of all instances of organizational_project_role.

Formal propositions

WR1: For each instance of organizational_project_role, there shall be a reference to the organizational_project_role instance from an attribute of another entity.

5.2.4.35 dependent_instantiable_person_and_organization_role

The dependent_instantiable_person_and_organization_role rule specifies that each instance of person_and_organization_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_person_and_organization_role FOR
    (person_and_organization_role);
WHERE
  WR1:  SIZEOF ( QUERY (p <* person_and_organization_role |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

person_and_organization_role: the set of all instances of person_and_organization_role.

Formal propositions

WR1: For each instance of person_and_organization_role, there shall be a reference to the person_and_organization_role instance from an attribute of another entity.

5.2.4.36 dependent_instantiable_pre_defined_colour

The dependent_instantiable_pre_defined_colour rule specifies that each instance of pre_defined_colour is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_pre_defined_colour FOR
    (pre_defined_colour);
WHERE
  WR1:  SIZEOF ( QUERY (p <* pre_defined_colour |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_colour: the set of all instances of pre_defined_colour.

Formal propositions

WR1: For each instance of pre_defined_colour, there shall be a reference to the pre_defined_colour instance from an attribute of another entity.

5.2.4.37 dependent_instantiable_pre_defined_symbol

The dependent_instantiable_pre_defined_symbol rule specifies that each instance of pre_defined_symbol is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_pre_defined_symbol FOR
    (pre_defined_symbol);
WHERE
  WR1:  SIZEOF ( QUERY (p <* pre_defined_symbol |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_symbol: the set of all instances of pre_defined_symbol.

Formal propositions

WR1: For each instance of pre_defined_symbol, there shall be a reference to the pre_defined_symbol instance from an attribute of another entity.

5.2.4.38 dependent_instantiable_precision_qualifier

The dependent_instantiable_precision_qualifier rule specifies that each instance of precision_qualifier is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_precision_qualifier FOR
    (precision_qualifier);
WHERE
  WR1:  SIZEOF ( QUERY (p <* precision_qualifier |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

precision_qualifier: the set of all instances of precision_qualifier.

Formal propositions

WR1: For each instance of precision_qualifier, there shall be a reference to the precision_qualifier instance from an attribute of another entity.

5.2.4.39 dependent_instantiable_presentation_style_by_context

The dependent_instantiable_presentation_style_by_context rule specifies that each instance of presentation_style_by_context is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_presentation_style_by_context FOR
    (presentation_style_by_context);
WHERE
  WR1:  SIZEOF ( QUERY (p <* presentation_style_by_context |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

presentation_style_by_context: the set of all instances of presentation_style_by_context.

Formal propositions

WR1: For each instance of presentation_style_by_context, there shall be a reference to the presentation_style_by_context instance from an attribute of another entity.

5.2.4.40 dependent_instantiable_product_definition_context_role

The dependent_instantiable_product_definition_context_role rule specifies that each instance of product_definition_context_role is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_product_definition_context_role FOR
    (product_definition_context_role);
WHERE
  WR1:  SIZEOF ( QUERY (p <* product_definition_context_role |
        NOT (SIZEOF (USEDIN (p,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

product_definition_context_role: the set of all instances of product_definition_context_role.

Formal propositions

WR1: For each instance of product_definition_context_role, there shall be a reference to the product_definition_context_role instance from an attribute of another entity.

5.2.4.41 dependent_instantiable_resource_requirement_type

The dependent_instantiable_resource_requirement_type rule specifies that each instance of resource_requirement_type is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_resource_requirement_type FOR
    (resource_requirement_type);
WHERE
  WR1:  SIZEOF ( QUERY (r <* resource_requirement_type |
        NOT (SIZEOF (USEDIN (r,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

resource_requirement_type: the set of all instances of resource_requirement_type.

Formal propositions

WR1: For each instance of resource_requirement_type, there shall be a reference to the resource_requirement_type instance from an attribute of another entity.

5.2.4.42 dependent_instantiable_retention

The dependent_instantiable_retention rule specifies that each instance of retention is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_retention FOR
    (retention);
WHERE
  WR1:  SIZEOF ( QUERY (r <* retention |
        NOT (SIZEOF (USEDIN (r,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

retention: the set of all instances of retention.

Formal propositions

WR1: For each instance of retention, there shall be a reference to the retention instance from an attribute of another entity.

5.2.4.43 dependent_instantiable_standard_uncertainty

The dependent_instantiable_standard_uncertainty rule specifies that each instance of standard_uncertainty is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_standard_uncertainty FOR
    (standard_uncertainty);
WHERE
  WR1:  SIZEOF ( QUERY (s <* standard_uncertainty |
        NOT (SIZEOF (USEDIN (s,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

standard_uncertainty: the set of all instances of standard_uncertainty.

Formal propositions

WR1: For each instance of standard_uncertainty, there shall be a reference to the standard_uncertainty instance from an attribute of another entity.

5.2.4.44 dependent_instantiable_symbol_colour

The dependent_instantiable_symbol_colour rule specifies that each instance of symbol_colour is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_symbol_colour FOR
    (symbol_colour);
WHERE
  WR1:  SIZEOF ( QUERY (s <* symbol_colour |
        NOT (SIZEOF (USEDIN (s,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

symbol_colour: the set of all instances of symbol_colour.

Formal propositions

WR1: For each instance of symbol_colour, there shall be a reference to the symbol_colour instance from an attribute of another entity.

5.2.4.45 dependent_instantiable_text_style

The dependent_instantiable_text_style rule specifies that each instance of text_style is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_text_style FOR
    (text_style);
WHERE
  WR1:  SIZEOF ( QUERY (t <* text_style |
        NOT (SIZEOF (USEDIN (t,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

text_style: the set of all instances of text_style.

Formal propositions

WR1: For each instance of text_style, there shall be a reference to the text_style instance from an attribute of another entity.

5.2.4.46 dependent_instantiable_text_style_for_defined_font

The dependent_instantiable_text_style_for_defined_font rule specifies that each instance of text_style_for_defined_font is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_text_style_for_defined_font FOR
    (text_style_for_defined_font);
WHERE
  WR1:  SIZEOF ( QUERY (t <* text_style_for_defined_font |
        NOT (SIZEOF (USEDIN (t,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

text_style_for_defined_font: the set of all instances of text_style_for_defined_font.

Formal propositions

WR1: For each instance of text_style_for_defined_font, there shall be a reference to the text_style_for_defined_font instance from an attribute of another entity.

5.2.4.47 dependent_instantiable_time_interval_role

The dependent_instantiable_time_interval_role rule specifies that each instance of time_interval_role is dependent on the usage to define another entity.

*)
RULE dependent_instantiable_time_interval_role FOR
    (time_interval_role);
WHERE
  WR1:  SIZEOF ( QUERY (t <* time_interval_role |
        NOT (SIZEOF (USEDIN (t,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

time_interval_role: the set of all instances of time_interval_role.

Formal propositions

WR1: For each instance of time_interval_role, there shall be a reference to the time_interval_role instance from an attribute of another entity.

5.2.4.48 dependent_instantiable_tolerance_value

The dependent_instantiable_tolerance_value rule specifies that each instance of tolerance_value is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_tolerance_value FOR
    (tolerance_value);
WHERE
  WR1:  SIZEOF ( QUERY (t <* tolerance_value |
        NOT (SIZEOF (USEDIN (t,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

tolerance_value: the set of all instances of tolerance_value.

Formal propositions

WR1: For each instance of tolerance_value, there shall be a reference to the tolerance_value instance from an attribute of another entity.

5.2.4.49 dependent_instantiable_type_qualifier

The dependent_instantiable_type_qualifier rule specifies that each instance of type_qualifier is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_type_qualifier FOR
    (type_qualifier);
WHERE
  WR1:  SIZEOF ( QUERY (t <* type_qualifier |
        NOT (SIZEOF (USEDIN (t,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

type_qualifier: the set of all instances of type_qualifier.

Formal propositions

WR1: For each instance of type_qualifier, there shall be a reference to the type_qualifier instance from an attribute of another entity.

5.2.4.50 dependent_instantiable_uncertainty_qualifier

The dependent_instantiable_uncertainty_qualifier rule specifies that each instance of uncertainty_qualifier is dependent on the usage to define another entity.
*)
RULE dependent_instantiable_uncertainty_qualifier FOR
    (uncertainty_qualifier);
WHERE
  WR1:  SIZEOF ( QUERY (u <* uncertainty_qualifier |
        NOT (SIZEOF (USEDIN (u,'')) > 0 ))) = 0;
END_RULE;
(*

Argument definitions:

uncertainty_qualifier: the set of all instances of uncertainty_qualifier.

Formal propositions

WR1: For each instance of uncertainty_qualifier, there shall be a reference to the uncertainty_qualifier instance from an attribute of another entity.

5.2.4.51 design_constraint_requires_product_definition

The design_constraint_requires_product_definition rule ensures that each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'requirement', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'design constraint definition'.
*)
RULE design_constraint_requires_product_definition FOR
    (product_definition,
     product_definition_formation,
     product_related_product_category);
WHERE
  WR1:  SIZEOF( QUERY( pdf <* product_definition_formation |
               (SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'requirement'
                 )) > 0) AND
               (SIZEOF( QUERY( pd <* USEDIN(pdf,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION.FORMATION') |
                  pd.frame_of_reference.name = 'design constraint definition'
                 )) <> 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

product_definition_formation: the set of all instances of product_definition_formation.

product_related_product_category: the set of all instances of product_related_product_category.

product_definition_formation: the set of all instances of product_definition_formation.

product_related_product_category: the set of all instances of product_related_product_category.

Formal propositions

WR1: Each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'requirement', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'design constraint definition'.

5.2.4.52 dimensionality_is_two_or_three

The dimensionality_is_two_or_three rule ensures that all representations with a geometric_representation_context are defined in a two-dimensional or three-dimensional coordinate system.
*)
RULE dimensionality_is_two_or_three FOR
    (geometric_representation_context);
WHERE
  WR1:  SIZEOF (QUERY (g <* geometric_representation_context |
               NOT ((g.coordinate_space_dimension = 2) OR
                    (g.coordinate_space_dimension = 3))
              )) = 0;
           
END_RULE;
(*

Argument definitions:

geometric_representation_context: the set of all instances of geometric_representation_context.

Formal propositions

WR1: Each geometric_representation_context shall have a coordinate_space_dimension equal to two or three.

5.2.4.53 draughting_subfigure_representation_layers

The draughting_subfigure_representation_layers rule ensures that every annotation_occurrence that is an item in a draughting_subfigure_representation is assigned to at least one layer.
*)
RULE draughting_subfigure_representation_layers FOR
    (draughting_subfigure_representation);
WHERE
  WR1:  SIZEOF (QUERY (dsr <* draughting_subfigure_representation |
               NOT (SIZEOF (QUERY (item <* dsr\representation.items |
                     ('AUTOMOTIVE_DESIGN.ANNOTATION_OCCURRENCE'
                      IN TYPEOF (item)) AND
                     (SIZEOF (USEDIN (item, 'AUTOMOTIVE_DESIGN.' +
                                            'PRESENTATION_LAYER_ASSIGNMENT.' +
                                            'ASSIGNED_ITEMS')
                       ) = 0)
                     )) = 0)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

draughting_subfigure_representation: the set of all instances of draughting_subfigure_representation.

Formal propositions

WR1: Every item of each draughting_subfigure_representation that is an annotation_occurrence shall be one of the assigned_items of at least one presentation_layer_assignment.

5.2.4.54 drawing_sheet_annotation_layers

The drawing_sheet_annotation_layers rule ensures that every annotation_occurrence that is an item in a drawing_sheet_revision is assigned to at least one layer.
*)
RULE drawing_sheet_annotation_layers FOR
    (drawing_sheet_revision);
WHERE
  WR1:  SIZEOF
               (QUERY (dsr <* drawing_sheet_revision |
           NOT (SIZEOF (QUERY (ao <* QUERY (it <* dsr\representation.items |
              ('AUTOMOTIVE_DESIGN.ANNOTATION_OCCURRENCE' IN TYPEOF (it))) |
              NOT (SIZEOF (USEDIN (ao, 'AUTOMOTIVE_DESIGN.' +
                                       'PRESENTATION_LAYER_ASSIGNMENT.' +
                                       'ASSIGNED_ITEMS')) >= 1)
                   ))=0)
               ))=0;
           
END_RULE;
(*

Argument definitions:

drawing_sheet_revision: the set of all instances of drawing_sheet_revision.

Formal propositions

WR1: Every item of each drawing_sheet_revision that is an annotation_occurrence shall be one of the assigned_items of at least one presentation_layer_assignment.

5.2.4.55 drawing_sheet_layout_usage

The drawing_sheet_layout_usage rule ensures that a drawing_sheet_layout is mapped as one of the items of a drawing_sheet_revision.
*)
RULE drawing_sheet_layout_usage FOR
    (mapped_item);
WHERE
  WR1:  SIZEOF (QUERY (dsl <* QUERY (mi <* mapped_item |
                 ('AUTOMOTIVE_DESIGN.DRAWING_SHEET_LAYOUT'
                     IN TYPEOF (mi.mapping_source.mapped_representation))) |
                 NOT (SIZEOF (USEDIN (dsl, '')) =
                     SIZEOF (QUERY (dsr <* USEDIN (dsl, 'AUTOMOTIVE_DESIGN.' +
                                         'REPRESENTATION.ITEMS') |
                     ('AUTOMOTIVE_DESIGN.DRAWING_SHEET_REVISION'
                        IN TYPEOF(dsr)))))
               )) = 0;
              
END_RULE;
(*

Argument definitions:

mapped_item: the set of all instances of mapped_item.

Formal propositions

WR1: Each mapped_item that is the mapping of a drawing_sheet_layout shall be one of the items in a drawing_sheet_revision.

5.2.4.56 drawing_view_annotation_layers

The drawing_view_annotation_layers rule ensures that every annotation_occurrence that is an item in a presentation_view is assigned to at least one layer.
*)
RULE drawing_view_annotation_layers FOR
    (presentation_view);
WHERE
  WR1:  SIZEOF
         (QUERY (pv <* presentation_view |
          NOT (SIZEOF (QUERY (ao <* QUERY (it <* pv\representation.items |
             ('AUTOMOTIVE_DESIGN.' +
              'ANNOTATION_OCCURRENCE' IN TYPEOF (it))) |
                  NOT (SIZEOF (USEDIN (ao, 'AUTOMOTIVE_DESIGN.' +
                              'PRESENTATION_LAYER_ASSIGNMENT.' +
                              'ASSIGNED_ITEMS')) >= 1)
                   ))=0)
               ))=0;
           
END_RULE;
(*

Argument definitions:

presentation_view: the set of all instances of presentation_view.

Formal propositions

WR1: Every item of each presentation_view that is an annotation_occurrence shall be one of the assigned_items of at least one presentation_layer_assignment.

5.2.4.57 event_occurrence_requires_event_occurrence_assignment

The event_occurrence_requires_event_occurrence_assignment rule ensures that each instance of event_occurrence that serves not as a base for another instance of event_occurrence, or as start or end date for a dated_effectivity is referenced by at least one instance of event_occurrence_assignment as the assigned_event_occurrence. This rule enforces the requirement for every event_reference to be assigned to product data at least once.
*)
RULE event_occurrence_requires_event_occurrence_assignment FOR
    (event_occurrence,
     event_occurrence_assignment,
     relative_event_occurrence);
WHERE
  WR1:  SIZEOF( QUERY( eo <* event_occurrence |
               (SIZEOF( USEDIN( eo, 'AUTOMOTIVE_DESIGN.' +
                        'RELATIVE_EVENT_OCCURRENCE.BASE_EVENT')
                 ) = 0) AND 
               (SIZEOF( USEDIN( eo, 'AUTOMOTIVE_DESIGN.' + 
                        'EVENT_OCCURRENCE_ASSIGNMENT.ASSIGNED_EVENT_OCCURRENCE')
                 ) = 0) AND
               (SIZEOF( USEDIN( eo, 'AUTOMOTIVE_DESIGN.' + 
                        'DATED_EFFECTIVITY.EFFECTIVITY_START_DATE')
                 ) = 0) AND
               (SIZEOF( USEDIN( eo, 'AUTOMOTIVE_DESIGN.' + 
                        'DATED_EFFECTIVITY.EFFECTIVITY_END_DATE')
                 ) = 0)
              )) = 0;    
END_RULE;

(*

Argument definitions:

event_occurrence: the set of all instances of event_occurrence.

event_occurrence_assignment: the set of all instances of event_occurrence_assignment.

relative_event_occurrence: the set of all instances of relative_event_occurrence.

event_occurrence_assignment: the set of all instances of event_occurrence_assignment.

relative_event_occurrence: the set of all instances of relative_event_occurrence.

Formal propositions

WR1: Each event_occurrence shall be used at least once either as a base_event by an instance of relative_event_occurrence, as an effectivity_start_date or effectivity_end_date by an instance of dated_effectivity, or as the assigned_event_occurrence of an instance of event_occurrence_assignment.

5.2.4.58 executed_action_requires_action_status

The executed_action_requires_action_status rule specifies that each instance of executed_action shall be referenced by at most one instance of action_status as assigned_action.
*)
RULE executed_action_requires_action_status FOR
    (executed_action);
WHERE
  WR1:  SIZEOF( QUERY( ea <* executed_action |
                       SIZEOF( USEDIN( ea, 'AUTOMOTIVE_DESIGN.' + 
                                           'ACTION_STATUS.ASSIGNED_ACTION')
                     ) 
> 1
              )) = 0;        
END_RULE;
(*

Argument definitions:

executed_action: the set of all instances of executed_action.

Formal propositions

WR1: Each instance of executed_action shall be referenced by at most  one instance of action_status as assigned_action.

5.2.4.59 externally_defined_class_with_known_source_requirement

The externally_defined_class_with_known_source_requirement rule specifies that each instance of externally_defined_class which references as the source a known_source is contained in the set of items of exactly one applied_organization_assignment which references as its role an organization_role with a name of 'class supplier'. This rule enforces the requirement for every Plib_class_reference to have a supplier_bsu.
*)
RULE externally_defined_class_with_known_source_requirement FOR
    (externally_defined_class);
WHERE
  WR1:  SIZEOF( QUERY( edc <* externally_defined_class |
               ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                TYPEOF(edc.source)) AND
               (SIZEOF( QUERY( aoa <* USEDIN(edc,'AUTOMOTIVE_DESIGN.APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS') |
                  aoa.role.name = 'class supplier'
                 )) = 0)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

externally_defined_class: the set of all instances of externally_defined_class.

Formal propositions

WR1: Each instance of externally_defined_class which references as the source a known_source shall be member in the set of items of an applied_organization_assignment. This organization_assignment shall reference as its role an organization_role with a name of 'class supplier'.

5.2.4.60 fill_area_style_tile_symbol_constraint

The fill_area_style_tile_symbol_constraint rule ensures that a pre_defined_symbol does not participate in the definition of a fill_area_style_tile_symbol_with_style.
*)
RULE fill_area_style_tile_symbol_constraint FOR
    (fill_area_style_tile_symbol_with_style);
WHERE
  WR1:  SIZEOF (QUERY (fast <* fill_area_style_tile_symbol_with_style |
                 (('AUTOMOTIVE_DESIGN.DEFINED_SYMBOL' IN
                     TYPEOF(fast.symbol\styled_item.item)) AND
                 NOT ('AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_SYMBOL' IN
                         TYPEOF(fast.symbol\styled_item.
                                item\defined_symbol.definition)))
               )) = 0;
           
END_RULE;
(*

Argument definitions:

fill_area_style_tile_symbol_with_style: the set of all instances of fill_area_style_tile_symbol_with_style.

Formal propositions

WR1: Each fill_area_style_tile_symbol_with_style that has an implicit definition shall be defined by an externally_defined_symbol.

5.2.4.61 full_model_change_completeness_for_action_property

The full_model_change_completeness_for_action_property rule specifies that each instance of action_property with a name of 'full model change' shall be referenced as the property by two action_property_representations specifying as representations the original representation and the replacement representation. The one specifying the original representation shall have the name 'original representation', the other the name 'replacement representation'. If an additional instance of action_property_representation with name 'added elements' references this instance of action_property as property, the representation shall contain in its set of items only representation_items that are also in the set of items in the replacement representation. If an additional instance of action_property_representation with name 'deleted elements' references this instance of action_property as property, the representation shall contain in its set of items only representation_items that are also in the set of items in the original representation.
*)
RULE full_model_change_completeness_for_action_property FOR
    (action_property);
WHERE
  WR1:  SIZEOF (QUERY( ap <* action_property |
               (ap.name = 'full model change') AND
               (SIZEOF( QUERY( apr <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                        'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                   apr.name = 'original representation'
                  )) = 0)
              )) = 0;
           
  WR2:  SIZEOF (QUERY( ap <* action_property |
               (ap.name = 'full model change') AND
               (SIZEOF( QUERY( apr <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                        'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                   apr.name = 'replacement representation'
                  )) = 0)
              )) = 0;
           
  WR3:  SIZEOF (QUERY( ap <* action_property |
               SIZEOF( QUERY( apr1 <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                       'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                 (apr1.name = 'added elements') AND
                 (SIZEOF( QUERY( apr2 <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                          'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                    (apr2.name = 'replacement representation') AND
                    (SIZEOF( QUERY( i1 <* apr1.representation.items |
                       SIZEOF( QUERY( i2 <* apr2.representation.items |
                         i1 :=: i2
                        )) > 0
                       )) <>
                      SIZEOF(apr1.representation.items))
                   )) > 0)
                )) > 0
              )) = 0;   
  WR4:  SIZEOF (QUERY( ap <* action_property |
               SIZEOF( QUERY( apr1 <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                       'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                 (apr1.name = 'deleted elements') AND
                 (SIZEOF( QUERY( apr2 <* USEDIN(ap,'AUTOMOTIVE_DESIGN.' +
                          'ACTION_PROPERTY_REPRESENTATION.PROPERTY') |
                    (apr2.name = 'original representation') AND
                    (SIZEOF( QUERY( i1 <* apr1.representation.items |
                       SIZEOF( QUERY( i2 <* apr2.representation.items |
                         i1 :=: i2
                        )) > 0
                       )) <>
                      SIZEOF(apr1.representation.items))
                   )) > 0)
                )) > 0
              )) = 0;   
END_RULE;
(*

Argument definitions:

action_property: the set of all instances of action_property.

Formal propositions

WR1: Each instance of action_property with a name of 'full model change' shall be referenced as property by a action_property_representation with a name of 'original representation'.

WR2: Each instance of action_property with a name of 'full model change' shall be referenced as property by a action_property_representation with a name of 'replacement representation'.

WR3: For an instance of action_property_representation with name 'added elements' referencing this instance of action_property as property, the representation shall contain in its set of items only representation_items that are also in the set of items in the representation that is refered by a action_property_representation that has a name of 'replacement representation' and refers to this instance of action_property.

WR4: For an instance of action_property_representation with name 'deleted elements' referencing this instance of action_property as property the representation shall contain in its set of items only representation_items that are also in the set of items in the representation that is refered by a action_property_representation that has a name of 'original representation' and refers to this instance of action_property.

5.2.4.62 full_model_change_completeness_for_property_definition

The full_model_change_completeness_for_property_definition rule specifies that each instance of property_definition with a name of 'full model change' shall be referenced as the definition by two property_definition_representations specifying as used_representations the original representation and the replacement representation. The one specifying the original representation shall have the name 'original representation', the other the name 'replacement representation'. If an additional instance of property_definition_representation with name 'added elements' references this instance of property_definition as definition, the used_representation shall contain in its set of items only representation_items that are also in the set of items in the replacement representation. If an additional instance of property_definition_representation with name 'deleted elements' references this instance of property_definition as definition, the used_representation shall contain in its set of items only representation_items that are also in the set of items in the original representation.
*)
RULE full_model_change_completeness_for_property_definition FOR
    (property_definition);
WHERE
  WR1:  SIZEOF( QUERY( pd <* property_definition |
               (pd.name = 'full model change') AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                  pdr.name = 'original representation'
                 )) = 0)
              )) = 0;
  WR2:  SIZEOF( QUERY( pd <* property_definition |
               (pd.name = 'full model change') AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                  pdr.name = 'replacement representation'
                 )) = 0)
              )) = 0;
  WR3:  SIZEOF( QUERY( pd <* property_definition |
               (SIZEOF( QUERY( pdr <* USEDIN( pd, 'AUTOMOTIVE_DESIGN.' + 
                        'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')|
                  (pdr.name = 'added elements') AND
                  (SIZEOF( QUERY( i <* pdr.used_representation.items |
                     SIZEOF( QUERY( pdr1 <* USEDIN( pd, 'AUTOMOTIVE_DESIGN.' + 
                             'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')|
                       (pdr1.name = 'replacement representation') AND
                       (NOT( i IN pdr1.used_representation.items))
                      )) > 0
                    )) > 0)
                 )) > 0 )
               )) = 0;   
           
  WR4:  SIZEOF( QUERY( pd <* property_definition |
              (SIZEOF( QUERY( pdr <* USEDIN( pd, 'AUTOMOTIVE_DESIGN.' + 
                       'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')|
                 (pdr.name = 'deleted elements') AND
                 (SIZEOF( QUERY( i <* pdr.used_representation.items |
                    SIZEOF( QUERY( pdr1 <* USEDIN( pd, 'AUTOMOTIVE_DESIGN.' + 
                            'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')|
                      (pdr1.name = 'original representation') AND
                      (NOT( i IN pdr1.used_representation.items))
                     )) > 0
                   )) > 0)
                )) > 0 )
              )) = 0;
           
           
END_RULE;
(*

Argument definitions:

property_definition: the set of all instances of property_definition.

Formal propositions

WR1: Each instance of property_definition with a name of 'full model change' shall be referenced as definition by a property_definition_representation with a name of 'original representation'.

WR2: Each instance of property_definition with a name of 'full model change' shall be referenced as definition by a property_definition_representation with a name of 'replacement representation'.

WR3: For an instance of property_definition_representation with name 'added elements' referencing this instance of property_definition as definition the used_representation shall contain in its set of items only representation_items that are also in the set of items in the representation that is refered by a property_definition_representation that has a name of 'replacement representation' and refers to this instance of property_definition.

WR4: For an instance of property_definition_representation with name 'deleted elements' referencing this instance of property_definition as definition the used_representation shall contain in its set of items only representation_items that are also in the set of items in the representation that is refered by a property_definition_representation that has a name of 'original representation' and refers to this instance of property_definition.

5.2.4.63 global_length_and_angle_units_2d_or_3d

The global_length_and_angle_units_2d_or_3d rule ensures that units of length and plane angle are given for every global_unit_assigned_context.
*)
RULE global_length_and_angle_units_2d_or_3d FOR
    (global_unit_assigned_context);
WHERE
  WR1:  SIZEOF (QUERY (guac <* global_unit_assigned_context |
               SIZEOF (guac.units) < 2
              ))=0;
           
  WR2:  SIZEOF (QUERY (guac <* global_unit_assigned_context |
               (SIZEOF (QUERY (x <* guac.units |
                  'AUTOMOTIVE_DESIGN.LENGTH_UNIT' IN TYPEOF (x)
                 )) <> 1) OR
               (SIZEOF (QUERY (x <* guac.units |
                  'AUTOMOTIVE_DESIGN.PLANE_ANGLE_UNIT' IN TYPEOF (x)
                 )) <> 1)
              ))=0; 
           
END_RULE;
(*

Argument definitions:

global_unit_assigned_context: the set of all instances of global_unit_assigned_context.

Formal propositions

WR1: Each global_unit_assigned_context shall have at least two elements in its set of units.

WR2: Each global_unit_assigned_context shall have exactly one length_unit and exactly one plane_angle_unit.

5.2.4.64 person_requires_person_and_organization

The person_requires_person_and_organization rule ensures that each instance of person shall be referenced by at least one instance of person_and_organization as the_person. This rule enforces the requirement for each person to have at least one organization specified the person belongs to.
*)
RULE person_requires_person_and_organization FOR
    (person);
WHERE
  WR1:  SIZEOF( QUERY( p <* person |
        	 SIZEOF( USEDIN(p, 'AUTOMOTIVE_DESIGN.PERSON_AND_ORGANIZATION.THE_PERSON')
        	  ) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

person: the set of all instances of person.

Formal propositions

WR1: Each instance of person shall be referenced by at least one instance of person_and_organization as the_person.

5.2.4.65 physical_instance_requires_product_definition

The physical_instance_requires_product_definition rule ensures that each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'physically realized product', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'physical occurrence'.
*)
RULE physical_instance_requires_product_definition FOR
    (product_definition,
     product_definition_formation,
     product_related_product_category);
WHERE
  WR1:  SIZEOF( QUERY( pdf <* product_definition_formation |
               (SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'physically realized product'
                 )) > 0) AND
               (SIZEOF( QUERY( pd <* USEDIN(pdf,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION.FORMATION') |
                  pd.frame_of_reference.name = 'physical occurrence'
                 )) <> 1)
              )) = 0;    
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

product_definition_formation: the set of all instances of product_definition_formation.

product_related_product_category: the set of all instances of product_related_product_category.

product_definition_formation: the set of all instances of product_definition_formation.

product_related_product_category: the set of all instances of product_related_product_category.

Formal propositions

WR1: Each instance of product_definition_formation which has an associated of_product that is referenced by a product_related_product_category with a name of 'physically realized product', is referenced as formation by exactly one instance of product_definition that references as its frame_of_reference a product_definition_context with a name of 'physical occurrence'.

5.2.4.66 plib_class_reference_requires_version

The plib_class_reference_requires_version rule specifies that each instance of externally_defined_class that has as its source a known_source is contained in the set of items of exactly one applied_external_identification_assignment which references as its role an identification_role with a name of 'version'. This rule enforces the requirement for every Plib_class_reference to have exactly one version.
*)
RULE plib_class_reference_requires_version FOR
    (externally_defined_class);
WHERE
  WR1:  SIZEOF( QUERY( edc <* externally_defined_class |
               ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                TYPEOF(edc.source)) AND
               (SIZEOF( QUERY( aei <* USEDIN(edc,'AUTOMOTIVE_DESIGN.APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT.ITEMS') |
                  aei.role.name = 'version'
                 )) <> 1)
              )) = 0;   
  WR2:  SIZEOF( QUERY( edc <* externally_defined_class |
               ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                TYPEOF(edc.source)) AND
               (SIZEOF( QUERY( aei <* USEDIN(edc,'AUTOMOTIVE_DESIGN.APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
                  aei.role.name = 'version'
                 )) > 0)
              )) = 0;   
END_RULE;
(*

Argument definitions:

externally_defined_class: the set of all instances of externally_defined_class.

Formal propositions

WR1: Each instance of externally_defined_class that has as its source a known_source is contained in the set of items of exactly one applied_external_identification_assignment which references as its role an identification_role with a name of 'version'.

WR2: An instance of externally_defined_class that has as its source a known_source may not be contained in the set of items of an applied_identification_assignment which references as its role an identification_role with a name of 'version'.

5.2.4.67 plib_property_reference_requires_name_scope

The plib_property_reference_requires_name_scope rule specifies that each instance of externally_defined_general_property that has as its source a known_source is referenced as the relating_item by exactly one instance of externally_defined_item_relationship which has a name of 'name scope' and which references as the related_item an externally_defined_class that has as its source a known_source. This rule enforces the requirement for every Plib_property_reference to have a name_scope.
*)
RULE plib_property_reference_requires_name_scope FOR
    (externally_defined_general_property);
WHERE
  WR1:  SIZEOF( QUERY( edgp <* externally_defined_general_property |
               ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                TYPEOF(edgp.source)) AND
               (SIZEOF( QUERY( edir <* USEDIN(edgp,'AUTOMOTIVE_DESIGN.' +
                        'EXTERNALLY_DEFINED_ITEM_RELATIONSHIP.RELATING_ITEM') |
                  (edir.name = 'name scope') AND
                  ('AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS' IN
                   TYPEOF(edir.related_item)) AND
                  ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                   TYPEOF(edir.related_item.source))
                 )) <> 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

externally_defined_general_property: the set of all instances of externally_defined_general_property.

Formal propositions

WR1: Each instance of externally_defined_general_property that has as its source a known_source is referenced as the relating_item by exactly one instance of externally_defined_item_relationship which has a name of 'name scope' and which references as the related_item an externally_defined_class that has as its source a known_source.

5.2.4.68 plib_property_reference_requires_version

The plib_property_reference_requires_version rule specifies that each instance of externally_defined_general_property that has as its source a known_source is contained in the set of items of exactly one applied_external_identification_assignment which references as its role an identification_role with a name of 'version'. This rule enforces the requirement for every Plib_property_reference to have a version.
*)
RULE plib_property_reference_requires_version FOR
    (externally_defined_general_property);
WHERE
  WR1:  SIZEOF( QUERY( edgp <* externally_defined_general_property |
               ('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                TYPEOF(edgp.source)) AND
               (SIZEOF( QUERY( edir <* USEDIN(edgp,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT.ITEMS') |
                  (edir.role.name = 'version')
                 )) <> 1)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

externally_defined_general_property: the set of all instances of externally_defined_general_property.

Formal propositions

WR1: Each instance of externally_defined_general_property that has as its source a known_source is contained in the set of items of exactly one applied_external_identification_assignment which references as its role an identification_role with a name of 'version'.

5.2.4.69 presentation_layer_assignment_constraint_2d_or_3d

The presentation_layer_assignment_constraint_2d_or_3d rule ensures that every element of a layer that is a point, curve, or surface is an element in a shape_representation and that every element of a layer that is an annotation_occurrence is one of the items in an draughting_subfigure_representation, draughting_model, presentation_area, or presentation_view.
*)
RULE presentation_layer_assignment_constraint_2d_or_3d FOR
    (presentation_layer_assignment);
WHERE
  WR1:  SIZEOF (QUERY (pla <* presentation_layer_assignment |
               NOT (SIZEOF (QUERY (pnt <* QUERY (item <* pla.assigned_items |
                    ('AUTOMOTIVE_DESIGN.POINT' IN TYPEOF (item))) |
                  NOT (SIZEOF (QUERY (rep <* USEDIN (pnt,
                             'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                         ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION'
                               IN TYPEOF (rep)))) = 0)
                    ))=0
               )))=0;   
           
  WR2:  SIZEOF (QUERY (pla <* presentation_layer_assignment |
               NOT (SIZEOF (QUERY (crv <* QUERY (item <* pla.assigned_items |
                    ('AUTOMOTIVE_DESIGN.CURVE' IN TYPEOF (item))) |
                  NOT (SIZEOF (QUERY (rep <* USEDIN (crv,
                             'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                         ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION'
                               IN TYPEOF (rep)))) = 0)
                    ))=0
               )))=0;   
           
  WR3:  SIZEOF (QUERY (pla <* presentation_layer_assignment |
               NOT (SIZEOF (QUERY (srf <* QUERY (item <* pla.assigned_items|
                    ('AUTOMOTIVE_DESIGN.SURFACE' IN TYPEOF (item))) |
                   NOT  (SIZEOF (QUERY (rep <* USEDIN (srf,
                               'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                           ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION'
                                 IN TYPEOF (rep)))) = 0)
                    ))=0
               )))=0;   
           
  WR4:  SIZEOF (QUERY (pla <* presentation_layer_assignment |
               NOT (SIZEOF (QUERY (ao <* QUERY (item <* pla.assigned_items|
                      ('AUTOMOTIVE_DESIGN.ANNOTATION_OCCURRENCE'
                        IN TYPEOF (item))) |
                 NOT (SIZEOF (QUERY (ur <* using_representations(ao) |
                   NOT (SIZEOF (TYPEOF(ur) *
                      ['AUTOMOTIVE_DESIGN.' +
                       'DRAUGHTING_SUBFIGURE_REPRESENTATION',
                       'AUTOMOTIVE_DESIGN.DRAUGHTING_MODEL',
                       'AUTOMOTIVE_DESIGN.PRESENTATION_AREA',
                       'AUTOMOTIVE_DESIGN.PRESENTATION_VIEW']) = 1)
                 )) = 0)
                 ))=0
               )))=0;   
        
           
END_RULE;
(*

Argument definitions:

presentation_layer_assignment: the set of all instances of presentation_layer_assignment.

Formal propositions

WR1: Every point that is one of the assigned_items of a presentation_layer_assignment shall also be a member of the set of items of a shape_representation.

WR2: Every curve that is one of the assigned_items of a presentation_layer_assignment shall also be a member of the set of items of a shape_representation.

WR3: Every surface that is one of the assigned_items of a presentation_layer_assignment shall also be a member of the set of items of a shape_representation.

WR4: Every annotation_occurrence that is one of the assigned_items of a presentation_layer_assignment shall also be a member of the set of items of an draughting_subfigure_representation, draughting_model, presentation_area, or presentation_view.

5.2.4.70 presentation_view_presented_once

The presentation_view_presented_once rule ensures that each presentation_view is participating in exactly one presentation_area.
*)
RULE presentation_view_presented_once FOR
    (presentation_view);
WHERE
  WR1:  SIZEOF ( QUERY  ( pv <* presentation_view |
        (SIZEOF ( QUERY ( rm <* USEDIN ( pv, 'AUTOMOTIVE_DESIGN.REPRESENTATION_MAP.' +
                     'MAPPED_REPRESENTATION' ) |
             (SIZEOF ( USEDIN ( rm, 'AUTOMOTIVE_DESIGN.MAPPED_ITEM.MAPPING_SOURCE' ) ) <> 1 )
             OR
             (SIZEOF ( QUERY ( mi <* USEDIN ( rm, 'AUTOMOTIVE_DESIGN.MAPPED_ITEM.MAPPING_SOURCE' ) |
             (SIZEOF ( USEDIN ( mi,  'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS' ) ) <> 1 )
             OR
             (SIZEOF ( QUERY ( r <* USEDIN ( mi, 'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS' ) |
                     NOT ('AUTOMOTIVE_DESIGN.PRESENTATION_AREA' IN TYPEOF ( r )) 
                      )) <> 0 )
              )) <> 0 )
        )) <> 0 ))) = 0;
        
END_RULE;
(*

Argument definitions:

presentation_view: the set of all instances of presentation_view.

Formal propositions

WR1: Each instance of presentation_view shall be the mapped_representation of exactly one representation_map. This representation_map shall be the mapping_source of exactly one mapped_item that is one of the items of a presentation_area.

5.2.4.71 product_concept_feature_requires_category

The product_concept_feature_requires_category rule specifies that each instance of product_concept_feature is contained in the set of items of exactly one applied_group_assignment which has as the role an object_role with a name of 'specification category member' and which references as the assigned_group a product_concept_feature_category. This rule enforces the requirement for every Specification to have one Specification_category.
*)
RULE product_concept_feature_requires_category FOR
    (product_concept_feature,
     product_concept_feature_category);
WHERE
 wr1:
        SIZEOF ( QUERY ( pcf <* product_concept_feature |
                 (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE',
                 'AUTOMOTIVE_DESIGN.' + 'CONDITIONAL_CONCEPT_FEATURE'] * TYPEOF(pcf))
                  = 0) AND (SIZEOF ( QUERY ( aga <* USEDIN ( pcf ,
                'AUTOMOTIVE_DESIGN.' + 'APPLIED_GROUP_ASSIGNMENT.' +
                  'ITEMS' ) | ( aga.role.name = 
                 'specification category member' ) AND (
                   'AUTOMOTIVE_DESIGN.' + 'PRODUCT_CONCEPT_FEATURE_CATEGORY'
                IN TYPEOF ( aga.assigned_group ) ) ) ) <> 1 ) ) ) =  0;
END_RULE;
(*

Argument definitions:

product_concept_feature: the set of all instances of product_concept_feature.

product_concept_feature_category: the set of all instances of product_concept_feature_category.

product_concept_feature_category: the set of all instances of product_concept_feature_category.

Formal propositions

WR1: Each instance of product_concept_feature is contained in the set of items of exactly one applied_group_assignment which has as the role an object_role with a name of 'specification category member' and which references as the assigned_group a product_concept_feature_category.

5.2.4.72 product_definition_replacement_requires_effectivity_assignment

The product_definition_replacement_requires_effectivity_assignment rule specifies that each instance of product_definition_relationship with a name of 'definition replacement' shall be referenced by at least one instance of applied_effectivity_assignment specifying the start of the validity. This rule enforces the requirement for every instance of Replaced_definition_relationship to have at least one Effectivity applied to it specifiying the start of the validity of the replacement.
*)
RULE product_definition_replacement_requires_effectivity_assignment FOR
    (applied_effectivity_assignment,
     product_definition_relationship);
WHERE
  WR1:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'definition replacement') AND
               (SIZEOF( USEDIN(pdr,'AUTOMOTIVE_DESIGN.APPLIED_EFFECTIVITY_ASSIGNMENT.ITEMS') 
                  ) = 0)
              )) = 0;                
              
END_RULE;
(*

Argument definitions:

applied_effectivity_assignment: the set of all instances of applied_effectivity_assignment.

product_definition_relationship: the set of all instances of product_definition_relationship.

product_definition_relationship: the set of all instances of product_definition_relationship.

Formal propositions

WR1: For each instance of product_definition_relationship with a name of 'definition replacement', there shall be at least one instance of applied_effectivity_assignment that contains the instance in its set of items.

5.2.4.73 product_requires_category

The product_requires_category rule specifies that each instance of product shall be referenced by at least one product_related_product_category.
*)
RULE product_requires_category FOR
    (product,
     product_related_product_category);
WHERE
  WR1:  SIZEOF( QUERY( p <* product |
               SIZEOF( USEDIN(p,'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS')
                 ) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

product: the set of all instances of product.

product_related_product_category: the set of all instances of product_related_product_category.

product_related_product_category: the set of all instances of product_related_product_category.

Formal propositions

WR1: Each instance of product shall be referenced by at least one product_related_product_category.

5.2.4.74 product_requires_id_owner

The product_requires_id_owner rule specifies that each instance of product that is referenced by an product_related_product_category with a name of 'part', 'tool', or 'raw material' shall be either referenced by an instance of applied_person_and_organization_assignment or by an instance of applied_organization_assignment. This rule enforces the requirement that for every Item an owner shall be specified for its id.
*)
RULE product_requires_id_owner
 FOR
    (product);
WHERE
  WR1:  SIZEOF ( QUERY ( prod <* product | 
        (SIZEOF( QUERY ( prpc <* USEDIN (prod, 'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
            prpc.name IN ['part', 'tool', 'raw material'] )) > 0 )
        AND
        (SIZEOF( QUERY (apoa <* USEDIN ( prod, 'AUTOMOTIVE_DESIGN.APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT.ITEMS' ) |
            apoa\person_and_organization_assignment.role.name 
  = 'id owner' ))  +
        (SIZEOF( QUERY (oa <* USEDIN ( prod, 'AUTOMOTIVE_DESIGN.APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS' ) |
            oa\organization_assignment.role.name = 'id owner' ))
             <> 
 1)
        )) = 0;
END_RULE;
(*

Argument definitions:

product: the set of all instances of product.

Formal propositions

WR1: Each instance of product that is referenced by an product_related_product_category with a name of 'part', 'tool', or 'raw material' is contained in the set of items of either exactly one applied_person_and_organization_assignment which references as its role an person_and_organization_role with a name of 'id owner' or exactly one applied_organization_assignment which references as its role an organization_role with a name of 'id owner'.

5.2.4.75 product_requires_version

The product_requires_version rule ensures that each instance of product is referenced by at least one instance of product_definition_formation. This rule enforces the requirement for every Item to have at least one Item version associated to it.
*)
RULE product_requires_version FOR
    (product);
WHERE
  WR1:  SIZEOF( QUERY ( prod <* product|
             ( SIZEOF ( USEDIN ( prod, 'AUTOMOTIVE_DESIGN.' + 
                'PRODUCT_DEFINITION_FORMATION.OF_PRODUCT' )
             ) = 0 )
             ) ) = 0;
END_RULE;
(*

Argument definitions:

product: the set of all instances of product.

Formal propositions

WR1: For each instance of product there shall be one or more instances of product_definition_formation that refers as of_product attribute to this instance of product.

5.2.4.76 restrict_action_resource_requirement_for_process_operation

The restrict_action_resource_requirement_for_process_operation rule specifies that each instance of action with a name of 'process operation' shall only be referenced by at most one instance of action_resource_requirement with a name of 'reference tool'. Each instance of action_resource_requirement with a name of 'reference tool' shall be of type requirement_for_action_resource and shall have exactly one item in its set of resources that references an instance of action_resource which is a product_definition_resource. The only names permitted for action_resource_requirement shall be 'reference tool' or 'non reference tool'. This rule enforces the requirement for every Process operation to have at most one resource as the reference tool associated to it where the reference tool has to be associated to an Item version.
*)
RULE restrict_action_resource_requirement_for_process_operation FOR
    (action,
     action_resource_requirement);
WHERE
  WR1:  SIZEOF( QUERY( a <* action |
                (a.name = 'process operation') AND
                (SIZEOF( QUERY( arr <* USEDIN( a, 'AUTOMOTIVE_DESIGN.' +
                                'ACTION_RESOURCE_REQUIREMENT.OPERATIONS') |
                         arr.name = 'reference tool'
                )) > 1 )
        )) = 0;      
  WR2:  SIZEOF( QUERY( arr <* action_resource_requirement |
                (arr.name = 'reference tool') AND 
                (NOT ('AUTOMOTIVE_DESIGN.REQUIREMENT_FOR_ACTION_RESOURCE' IN
                      TYPEOF(arr))) AND   
        (SIZEOF( QUERY( ar <* arr\requirement_for_action_resource.resources |
                         'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_RESOURCE' IN 
                         TYPEOF(ar)
                 )) <> 1 )
        )) = 0;
              
  WR3:  SIZEOF( QUERY( arr <* action_resource_requirement |
                (arr.name <> 'reference tool') AND
                (arr.name <> 'non reference tool')
        )) = 0;      
END_RULE;
(*

Argument definitions:

action: the set of all instances of action.

action_resource_requirement: the set of all instances of action_resource_requirement.

action_resource_requirement: the set of all instances of action_resource_requirement.

Formal propositions

WR1: For each instance of action with a name of 'process operation' there shall be at most one instance of action_resource_requirement with a name of 'reference tool' that references the action in its set of operations.

WR2: Each instance of action_resource_requirement with a name of 'reference tool' shall be a requirement_for_action_resource and shall have exactly one item in its set of resources that references an instance of action_resource which is a product_definition_resource.

WR3: For each instance of action_resource_requirement the value of the name attribute shall be either 'reference tool' or 'non reference tool'.

5.2.4.77 restrict_alternative_definition

The restrict_alternative_definition rule specifies the restrictions that apply to product_definitions which reference as frame_of_reference a product_definition_context with a name of 'alternative definition'.
*)
RULE restrict_alternative_definition FOR
    (product_definition,
     product_definition_context);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'alternative definition') AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION') |
                  pdr.name = 'solution alternative definition'
                 )) <> 1)
              )) = 0;      
  WR2:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'alternative definition') AND
               NOT(pd.name IN ['technical','supplier','final','technical supplier',
                               'technical final','supplier final','technical supplier final',''])
              )) = 0;      
  WR3:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'alternative definition') AND
               (pd.name IN ['supplier','technical supplier','supplier final',
                            'technical supplier final']) AND
                (SIZEOF( QUERY(aoa <* USEDIN(pd.formation,'AUTOMOTIVE_DESIGN.' +
                                'APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS') |
                   aoa.role.name = 'supplier'
                  )) <> 1)
              )) = 0;      
  WR4:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'alternative definition') AND
               (pd.name IN ['final','technical final','supplier final',
                            'technical supplier final']) AND
               (SIZEOF( QUERY(pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
                  pdr.name = 'final specification'
                 )) = 0 ) AND
               
        (SIZEOF( QUERY(pd <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PROPERTY_DEFINITION.DEFINITION') |
                  SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                          'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                    (pdr.used_representation.name = 'final item characteristics' ) AND
                    (SIZEOF( QUERY( i <* pdr.used_representation.items |
                             'AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                             TYPEOF(i)
                      )) = SIZEOF(pdr.used_representation.items)) AND
                    (SIZEOF(pdr.used_representation.items) >= 2) AND
                    (SIZEOF( QUERY(i <* pdr.used_representation.items |
                       i.name = 'final item status'
                      )) = 1 )
                   )) > 0
                )) = 0 ) 
              )) = 0;                       
              
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

product_definition_context: the set of all instances of product_definition_context.

product_definition_context: the set of all instances of product_definition_context.

Formal propositions

WR1: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'alternative definition' shall participate as the related_product_definition in exactly one product_definition_relationship with a name of 'solution alternative definition'.

WR2: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'alternative definition' shall have a name of 'technical', 'supplier', 'final', 'technical supplier', 'technical final', 'supplier final', 'technical supplier final', or ''.

WR3: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'alternative definition' and which has a name of 'supplier', 'technical supplier', 'supplier final', or 'technical supplier final' shall be in the set of items of exactly one applied_organization_assignment which has as role an organization_role with a name of 'supplier'.

WR4: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'alternative definition' and which has a name of 'final', 'technical final', 'supplier final', or 'technical supplier final' shall either participate as the relating_product_definition in at least one product_definition_relationship with a name of 'final specification', or shall be referenced by a property_definition which is referenced as definition by a property_definition_representation which has as used_representation a representation which has a name of 'final item characteristics'. This representation shall only contain representation_items in its set of items which are of type descriptive_representation_item. This representation shall contain at least two representation_items in its set of items. One representation_item shall have a name of 'final item status'.

5.2.4.78 restrict_applied_action_assignment

The restrict_applied_action_assignment rule enforces the correct correlation between the types of items in the set of items of an applied_action_assignment and the type of the assigned_action, and its associated object_role .
*)
RULE restrict_applied_action_assignment FOR
    (applied_action_assignment,
     object_role);
WHERE
  WR1:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.description = 'activity element') AND
               NOT('AUTOMOTIVE_DESIGN.EXECUTED_ACTION' IN
                   TYPEOF(aaa.assigned_action))
              )) = 0; 
  WR2:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.description = 'activity element') AND
               NOT item_correlation (aaa.items, ['ACTION', 'ACTION_METHOD',
               'ACTION_PROPERTY', 'ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE',
               'CONFIGURATION_ITEM', 'CONFIGURATION_EFFECTIVITY', 
               'CONFIGURED_EFFECTIVITY_ASSIGNMENT', 'DOCUMENT_FILE', 
               'DRAUGHTING_MODEL', 'DRAWING_REVISION', 'GENERAL_PROPERTY', 
               'MATERIAL_DESIGNATION', 
               'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION', 
               'PRESENTATION_AREA', 'PRODUCT', 'PRODUCT_CONCEPT', 
               'PRODUCT_CONCEPT_FEATURE', 
               'PRODUCT_CONCEPT_FEATURE_ASSOCIATION', 
               'PRODUCT_CONCEPT_FEATURE_CATEGORY', 
               'PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE', 
               'PRODUCT_DEFINITION', 'PRODUCT_DEFINITION_FORMATION', 
               'PRODUCT_DEFINITION_RELATIONSHIP', 
               'PRODUCT_DEFINITION_SUBSTITUTE', 'PROPERTY_DEFINITION',
               'RESOURCE_PROPERTY', 'SHAPE_ASPECT', 'SHAPE_REPRESENTATION'])
               )) = 0;
  WR3:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (NOT EXISTS(aaa.role) OR
               (aaa.role.description = 'activity element')) AND
               (SIZEOF( QUERY( i <* aaa.items |
                  'AUTOMOTIVE_DESIGN.APPLIED_ACTION_ASSIGNMENT' IN
                  TYPEOF(i)
                 )) > 0)
              )) = 0;
  WR4:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.name = 'deliverable element') AND
               (NOT('AUTOMOTIVE_DESIGN.ELEMENT_DELIVERY' IN
                    TYPEOF(aaa.assigned_action)) OR
                (SIZEOF( QUERY( i <* aaa.items |
                  'AUTOMOTIVE_DESIGN.APPLIED_ACTION_ASSIGNMENT' IN
                  TYPEOF(i)
                 )) > 1) OR
                (SIZEOF( QUERY( i <* aaa.items |
                  ('AUTOMOTIVE_DESIGN.APPLIED_ACTION_ASSIGNMENT' IN
                   TYPEOF(i)) AND
                  (i\action_assignment.role.description <> 'activity element')
                 )) > 0))
              )) = 0;
  WR5:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.name = 'retention') AND
               NOT('AUTOMOTIVE_DESIGN.RETENTION' IN
                   TYPEOF(aaa.assigned_action))
              )) = 0; 
  WR6:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.name = 'retention') AND
               NOT item_correlation (aaa.items, ['ACTION', 'ACTION_DIRECTIVE',
               'ACTION_PROPERTY', 'ACTION_RELATIONSHIP',
               'APPLIED_ACTION_ASSIGNMENT',
               'APPLIED_CLASSIFICATION_ASSIGNMENT', 
               'ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE', 'CERTIFICATION', 
               'CLASS_SYSTEM', 'CONFIGURATION_EFFECTIVITY', 
               'CONFIGURATION_ITEM', 'CONFIGURED_EFFECTIVITY_ASSIGNMENT', 
               'DOCUMENT_FILE', 'DRAUGHTING_MODEL', 'DRAWING_REVISION', 
               'GENERAL_PROPERTY', 'MATERIAL_DESIGNATION', 
               'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION', 
               'ORGANIZATIONAL_PROJECT', 'PRESENTATION_AREA', 'PRODUCT', 
               'PRODUCT_CONCEPT', 'PRODUCT_CONCEPT_FEATURE', 
               'PRODUCT_CONCEPT_FEATURE_ASSOCIATION', 
               'PRODUCT_CONCEPT_FEATURE_CATEGORY', 
               'PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE', 
               'PRODUCT_DEFINITION', 'PRODUCT_DEFINITION_FORMATION', 
               'PRODUCT_DEFINITION_RELATIONSHIP', 
               'PRODUCT_DEFINITION_SUBSTITUTE', 'PROPERTY_DEFINITION', 
               'RESOURCE_PROPERTY', 'SHAPE_REPRESENTATION',
               'VERSIONED_ACTION_REQUEST'])
              )) = 0;
  WR7:  SIZEOF( QUERY( aaa <* applied_action_assignment |
               (aaa.role.name = 'test activity') AND
                NOT item_correlation (aaa.items, ['PROPERTY_DEFINITION'])
              )) = 0; 
END_RULE;
(*

Argument definitions:

applied_action_assignment: the set of all instances of applied_action_assignment.

object_role: the set of all instances of object_role.

object_role: the set of all instances of object_role.

Formal propositions

WR1: If the applied_action_assignment has an associated object_role with a description of 'activity element', the assigned_action shall be of type executed_action.

WR2: If the role has a description of 'activity element', only items of type action, action_method, action_property, assembly_component_usage_substitute, configuration_item, configuration_effectivity, configured_effectivity_assignment, document_file, draughting_model, drawing_revision, general_property, material_designation, mechanical_design_geometric_presentation_representation, presentation_area, product, product_concept, product_concept_feature, product_concept_feature_association, product_concept_feature_category, product_concept_feature_category_usage, product_definition, product_definition_formation, product_definition_relationship, product_definition_substitute, property_definition, resource_property, shape_aspect, or shape_representation shall be in the set of items.

WR3: If the applied_action_assignment has no associated object_role or has an associated object_role with a description of 'activity element', the set of items shall not contain items of type applied_action_assignment.

WR4: If the applied_action_assignment has an associated object_role with a name of 'deliverable element', the assigned_action shall be of type element_delivery, and only one item of type applied_action_assignment shall be in the set of items. This applied_action_assignment in the set of items shall have an associated object_role with a description of 'activity element'.

WR5: If the applied_action_assignment has an associated object_role with a name of 'retention', the assigned_action shall be of type retention.

WR6: If the role has a name of 'retention', only items of type action, action_directive, action_property, action_relationship, applied_action_assignment, applied_classification_assignment, assembly_component_usage_substitute, certification, class_system, configuration_effectivity, configuration_item, configured_effectivity_assignment, document_file, draughting_model, drawing_revision, general_property, material_designation, mechanical_design_geometric_presentation_representation, organizational_project, presentation_area, product, product_concept, product_concept_feature, product_concept_feature_association, product_concept_feature_category, product_concept_feature_category_usage, product_definition, product_definition_formation, product_definition_relationship, product_definition_substitute, property_definition, resource_property, shape_representation, or versioned_action_request shall be in the set of items.

WR7: If the role has a name of 'test activity', only items of type property_definition shall be in the set of items.

5.2.4.79 restrict_applied_action_request_assignment

The restrict_applied_action_request_assignment rule enforces the correct correlation between the types of items in the set of items of an applied_action_request_assignment and its associated object_role .
*)
RULE restrict_applied_action_request_assignment FOR
    (applied_action_request_assignment,
     object_role);
WHERE
  WR1:  SIZEOF( QUERY( aara <* applied_action_request_assignment |
               aara.role.name <> 'scope'
              )) = 0;
END_RULE;
(*

Argument definitions:

applied_action_request_assignment: the set of all instances of applied_action_request_assignment.

object_role: the set of all instances of object_role.

object_role: the set of all instances of object_role.

Formal propositions

WR1: The applied_action_request_assignment shall only be referenced by object_role instances that have a name of 'scope'.

5.2.4.80 restrict_applied_classification_assignment_role

The restrict_applied_classification_assignment_role rule ensures the correct correlation between the assigned_class of the applied_classification_assignment and the name of the classification_role referenced as the role.
*)
RULE restrict_applied_classification_assignment_role FOR
    (applied_classification_assignment);
WHERE
  WR1:  SIZEOF( QUERY( aca <* applied_classification_assignment |
               ('AUTOMOTIVE_DESIGN.CLASS' IN
                TYPEOF(aca.assigned_class)) AND
               NOT( aca.role.name IN ['definitional','non-definitional',''])
              )) = 0;
           
  WR2:  SIZEOF( QUERY( aca <* applied_classification_assignment |
               (aca.role.name IN ['definitional','non-definitional','']) AND
               NOT('AUTOMOTIVE_DESIGN.CLASS' IN
                   TYPEOF(aca.assigned_class))
              )) = 0;
           
  WR3:  SIZEOF( QUERY( aca <* applied_classification_assignment |
               ('AUTOMOTIVE_DESIGN.CLASS_SYSTEM' IN
                TYPEOF(aca.assigned_class)) AND
               (aca.role.name <> 'class system membership')
              )) = 0;
           
  WR4:  SIZEOF( QUERY( aca <* applied_classification_assignment |
               (aca.role.name = 'class system membership') AND
               NOT ('AUTOMOTIVE_DESIGN.CLASS_SYSTEM' IN
                    TYPEOF(aca.assigned_class))
              )) = 0;
           
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

Formal propositions

WR1: If the assigned_class of an applied_classification_assignment is of type class, the classification_role referenced by the role attribute has a value of either 'definitional', 'non-definitional', or ''.

WR2: If an applied_classification_assignment references as its role a classification_role with a name of either 'definitional', 'non-definitional', or '', the assigned_class shall be of type class.

WR3: If the assigned_class of an applied_classification_assignment is of type class_system, the classification_role referenced by the role attribute has a value of 'class system membership'.

WR4: If an applied_classification_assignment references as its role a classification_role with a name of 'class system membership', the assigned_class shall be of type class_system.

5.2.4.81 restrict_applied_event_occurrence_assignment

The restrict_applied_event_occurrence_assignment rule ensures that each instance of applied_event_occurrence_assignment that provides the context for an event_occurrence contains exactly one element in its set of items.
*)
RULE restrict_applied_event_occurrence_assignment FOR
    (applied_event_occurrence_assignment);
WHERE
  WR1:  SIZEOF( QUERY( eo <* applied_event_occurrence_assignment |
        (eo\event_occurrence_assignment.role.name = 'event context') AND
        (SIZEOF (eo.items) > 1) )) = 0;
END_RULE;
(*

Argument definitions:

applied_event_occurrence_assignment: the set of all instances of applied_event_occurrence_assignment.

Formal propositions

WR1: Each applied_event_occurrence_assignment that has a role with a name of 'event context' shall contain exactly one element in its set of items.

5.2.4.82 restrict_applied_organizational_project_assignment

The restrict_applied_organizational_project_assignment rule enforces the correct correlation between the types of items in the set of items of an applied_organizational_project_assignment and its associated object_role .
*)
RULE restrict_applied_organizational_project_assignment FOR
    (applied_organizational_project_assignment,
     object_role);
WHERE
  WR1:  SIZEOF( QUERY( aopa <* applied_organizational_project_assignment |
               (aopa.role.name = 'affecting project') AND
               NOT item_correlation (aopa.items, ['PRODUCT_CONCEPT'])
              )) = 0;
  WR2:  SIZEOF( QUERY( aopa <* applied_organizational_project_assignment |
               (aopa.role.name = 'work program') AND
               NOT item_correlation (aopa.items, ['EXECUTED_ACTION'])
              )) = 0;
END_RULE;
(*

Argument definitions:

applied_organizational_project_assignment: the set of all instances of applied_organizational_project_assignment.

object_role: the set of all instances of object_role.

object_role: the set of all instances of object_role.

Formal propositions

WR1: If the role has a name of 'affecting project', only items of type product_concept shall be in the set of items.

WR2: If the role has a name of 'work program', only items of type executed_action shall be in the set of items.

5.2.4.83 restrict_approval

The restrict_approval rule specifies the constraints that apply to an approval and to an approval_date_time in the context of automotive design.
*)
RULE restrict_approval FOR
    (approval,
     approval_date_time);
WHERE
  WR1:  SIZEOF( QUERY( a <* approval |
               SIZEOF( USEDIN(a,'AUTOMOTIVE_DESIGN.APPROVAL_DATE_TIME.DATED_APPROVAL')
                 ) > 2
              )) = 0;
           
  WR2:  SIZEOF( QUERY( adt <* approval_date_time |
               (NOT EXISTS(adt.role)) OR
               (NOT(adt.role.name IN ['actual','planned']))
              )) = 0;   
  WR3:  SIZEOF( QUERY( a <* approval |
                SIZEOF( QUERY( adt <* USEDIN(a,'AUTOMOTIVE_DESIGN.' +
                                      'APPROVAL_DATE_TIME.DATED_APPROVAL') |
                        adt.role.name = 'actual'
                      )) > 1
              )) = 0;
           
  WR4:  SIZEOF( QUERY( a <* approval |
                SIZEOF( QUERY( adt <* USEDIN(a,'AUTOMOTIVE_DESIGN.' +
                                      'APPROVAL_DATE_TIME.DATED_APPROVAL') |
                        adt.role.name = 'planned'
                      )) > 1
              )) = 0;
           
END_RULE;
(*

Argument definitions:

approval: the set of all instances of approval.

approval_date_time: the set of all instances of approval_date_time.

approval_date_time: the set of all instances of approval_date_time.

Formal propositions

WR1: Each approval shall be referenced by at most two approval_date_time.

WR2: Each approval_date_time shall have an object_role. This object_role shall have a name of either 'actual' or 'planned'.

WR3: Each approval shall be referenced by at most one approval_date_time that has a name of 'actual'.

WR4: Each approval shall be referenced by at most one approval_date_time that has a name of 'planned'.

5.2.4.84 restrict_camera_image_in_view

The restrict_camera_image_in_view rule ensures that each camera_image is contained in exactly one presentation_view and that each presentation_view contains at most one camera_image. For more information see definition of Model_image in paragraph 4.2.316 and definition of View in paragraph 4.2.554.
*)
RULE restrict_camera_image_in_view FOR
    (camera_image,
     presentation_view);
WHERE
  WR1:  SIZEOF(QUERY(ci <* camera_image |
        (SIZEOF(QUERY(r<*USEDIN (ci,
        'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
        ('AUTOMOTIVE_DESIGN.PRESENTATION_VIEW' IN TYPEOF(r)))))<>1))=0;
  WR2:  SIZEOF(QUERY(pv <* presentation_view | 
        (SIZEOF(QUERY(ri<*pv\representation.items |
        'AUTOMOTIVE_DESIGN.CAMERA_IMAGE' IN TYPEOF(ri) ) ) ) > 1 )) = 0;
END_RULE;
(*

Argument definitions:

camera_image: the set of all instances of camera_image.

presentation_view: the set of all instances of presentation_view.

presentation_view: the set of all instances of presentation_view.

Formal propositions

WR1: Each camera_image shall be included in exactly one presentation_view.

WR2: Each presentation_view shall contain at most one camera_image.

5.2.4.85 restrict_centre_of_mass_representation

The restrict_centre_of_mass_representation rule specifies that each instance of representation with a name of 'centre of mass' shall contain exactly one item in its set of items. This representation_item shall be of type point and shall have a name of 'centre point'. This rule enforces the requirement for every Centre_of_mass to have exactly one Centre_point.
*)
RULE restrict_centre_of_mass_representation FOR
    (representation);
WHERE
  WR1:  SIZEOF( QUERY( r <* representation |
               (r.name = 'centre of mass') AND
               ((SIZEOF(r.items) <> 1) OR 
                (SIZEOF( QUERY( i <* r.items |
                   ('AUTOMOTIVE_DESIGN.POINT' IN TYPEOF(i)) AND
                   (i.name = 'centre point')
                   )) <> 1))
              )) = 0;
           
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of representation with a name of 'centre of mass' shall contain exactly one item in its set of items. This representation_item shall be of type point and shall have a name of 'centre point'.

5.2.4.86 restrict_class_system_assignment_for_approval_status

The restrict_class_system_assignment_for_approval_status rule specifies that each instance of approval_status shall be referenced by at most one instance of applied_classification_assignment that specifies the classification system for the approval_status.
*)
RULE restrict_class_system_assignment_for_approval_status FOR
    (applied_classification_assignment,
     approval_status);
WHERE
  WR1:  SIZEOF(QUERY(ent <* approval_status |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_CLASSIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'class system membership')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

approval_status: the set of all instances of approval_status.

approval_status: the set of all instances of approval_status.

Formal propositions

WR1: For each instance of approval_status there shall be only at most one instance of applied_classification_assignment with a role name of 'class system membership'.

5.2.4.87 restrict_class_system_assignment_for_class

The restrict_class_system_assignment_for_class rule specifies that each instance of class shall be referenced by at most one instance of applied_classification_assignment that specifies the classification system for the class.
*)
RULE restrict_class_system_assignment_for_class FOR
    (applied_classification_assignment,
     class);
WHERE
  WR1:  SIZEOF( QUERY( c <* class |
               SIZEOF( QUERY( aca <* USEDIN(c,'AUTOMOTIVE_DESIGN.' +
                        'CLASSIFICATION_ASSIGNMENT.ASSIGNED_CLASS') |
                  ((aca.role.name = 'class system membership')
                   AND
                  ( 'AUTOMOTIVE_DESIGN.APPLIED_CLASSIFICATION_ASSIGNMENT' IN TYPEOF (aca) ))
                 )) > 1
              )) = 0; --EXPRESS errors
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

class: the set of all instances of class.

class: the set of all instances of class.

Formal propositions

WR1: For each instance of class there shall be only at most one instance of applied_classification_assignment with a role name of 'class system membership' that references that instance of class.

5.2.4.88 restrict_class_system_assignment_for_descriptive_representation_item

The restrict_class_system_assignment_for_descriptive_representation_item rule specifies that each instance of descriptive_representation_item shall be referenced by at most one instance of applied_classification_assignment that specifies the classification system for the descriptive_representation_item.
*)
RULE restrict_class_system_assignment_for_descriptive_representation_item FOR
    (applied_classification_assignment,
     descriptive_representation_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* descriptive_representation_item |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_CLASSIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'class system membership')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

descriptive_representation_item: the set of all instances of descriptive_representation_item.

descriptive_representation_item: the set of all instances of descriptive_representation_item.

Formal propositions

WR1: For each instance of descriptive_representation_item there shall be only at most one instance of applied_classification_assignment with a role name of 'class system membership'.

5.2.4.89 restrict_class_system_assignment_for_document_type

The restrict_class_system_assignment_for_document_type rule specifies that each instance of document_type shall be referenced by at most one instance of applied_classification_assignment that specifies the classification system for the document_type.
*)
RULE restrict_class_system_assignment_for_document_type FOR
    (applied_classification_assignment,
     document_type);
WHERE
  WR1:  SIZEOF(QUERY(ent <* document_type |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_CLASSIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'class system membership')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

document_type: the set of all instances of document_type.

document_type: the set of all instances of document_type.

Formal propositions

WR1: For each instance of document_type there shall be only at most one instance of applied_classification_assignment with a role name of 'class system membership'.

5.2.4.90 restrict_class_system_assignment_for_security_classification_level

The restrict_class_system_assignment_for_security_classification_level rule specifies that each instance of security_classification_level shall be referenced by at most one instance of applied_classification_assignment that specifies the classification system for the security_classification_level.
*)
RULE restrict_class_system_assignment_for_security_classification_level FOR
    (applied_classification_assignment,
     security_classification_level);
WHERE
  WR1:  SIZEOF(QUERY(ent <* security_classification_level |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_CLASSIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'class system membership')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

applied_classification_assignment: the set of all instances of applied_classification_assignment.

security_classification_level: the set of all instances of security_classification_level.

security_classification_level: the set of all instances of security_classification_level.

Formal propositions

WR1: For each instance of security_classification_level there shall be only at most one instance of applied_classification_assignment with a role name of 'class system membership'.

5.2.4.91 restrict_concept_feature_operator

The restrict_concept_feature_operator rule restricts the name and usage of a concept_feature_operator.
*)
RULE restrict_concept_feature_operator FOR
    (concept_feature_operator);
WHERE
  WR1:   SIZEOF( QUERY( cfo <* concept_feature_operator |
                NOT(cfo.name IN ['and','or','oneof','not','implication'])
              )) = 0;
           
  WR2:  SIZEOF( QUERY( cfo <* concept_feature_operator |
               (cfo.name = 'implication') AND
               (SIZEOF( QUERY( cfrwc <* USEDIN(cfo,'AUTOMOTIVE_DESIGN.' +
                        'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.CONDITIONAL_OPERATOR') |
                  SIZEOF( QUERY( ccf <* USEDIN(cfrwc,'AUTOMOTIVE_DESIGN.' +
                          'CONDITIONAL_CONCEPT_FEATURE.CONDITION') |
                    NOT('AUTOMOTIVE_DESIGN.INCLUSION_PRODUCT_CONCEPT_FEATURE' IN
                        TYPEOF(ccf))
                   )) > 0
                 )) > 0 )
              )) = 0;
              
       WR3: SIZEOF( QUERY (cfo <* concept_feature_operator |
                 (cfo.name = 'not') AND
                 (SIZEOF(QUERY(cfrwc <* USEDIN(cfo, 'AUTOMOTIVE_DESIGN.' + 
                       'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.CONDITIONAL_OPERATOR') |
                       cfrwc.related_product_concept_feature :<>: cfrwc.relating_product_concept_feature
                )) >0 )
             ) ) = 0;
END_RULE;
(*

Argument definitions:

concept_feature_operator: the set of all instances of concept_feature_operator.

Formal propositions

WR1: Each instance of concept_feature_operator shall have a name of 'and', 'or', 'oneof, 'not', or 'implication'.

WR2: If the concept_feature_operator has a name of 'implication', it shall only be referenced as conditional_operator by concept_feature_relationship_with_condition instances which are referenced as the condition by conditional_concept_features which are of type inclusion_product_concept_feature.

WR3: If the concept_feature_operator has a name of 'not', it shall only be referenced as conditional_operator by concept_feature_relationship_with_condition instances where concept_feature_relationship.relating_product_concept_feature equals concept_feature_relationship.related_product_concept_feature.

5.2.4.92 restrict_configuration_design_for_product_class

The restrict_configuration_design_for_product_class rule enforces the restrictions that apply to the usage of a configuration_design when it relates to a configuration_item which references as its item_concept a product_class.
*)
RULE restrict_configuration_design_for_product_class FOR
    (configuration_design,
     product_class);
WHERE
  WR1:  SIZEOF( QUERY( cd <* configuration_design |
               (cd.name = 'functionality') AND
               (NOT ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION' IN
                     TYPEOF(cd.design)) OR
               (cd.design\product_definition.frame_of_reference.name <> 'functional definition'))
              )) = 0;
              
  WR2:  SIZEOF( QUERY( cd <* configuration_design |
               (cd.name = 'realization') AND
               (NOT ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION' IN
                     TYPEOF(cd.design)) OR
                (cd.design\product_definition.frame_of_reference.name <> 'conceptual definition'))
              )) = 0;
           
  WR3:  SIZEOF( QUERY( cd <* configuration_design |
               (cd.name IN ['functionality','realization']) AND
               (NOT ('AUTOMOTIVE_DESIGN.PRODUCT_CLASS' IN
                     TYPEOF(cd.configuration.item_concept)))
              )) = 0;
              
              
  WR4: SIZEOF ( QUERY (cd <* configuration_design | (cd.name =
                'design constraint usage') AND (NOT('AUTOMOTIVE_DESIGN.' +
                'PRODUCT_DEFINITION' IN TYPEOF ( cd.design ) ) OR
                (cd.design\product_definition.frame_of_reference.name <>
                 'design constraint definition')))) = 0;
              
  WR5:  SIZEOF( QUERY( cd <* configuration_design |
               (cd.name = 'physical instance basis') AND
               (NOT ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION' IN
                     TYPEOF(cd.design)) OR
                (cd.design\product_definition.frame_of_reference.name <> 'physical occurrence'))
              )) = 0;
              
  WR6:  SIZEOF( QUERY( cd <* configuration_design |
               (cd.name = 'physical instance basis') AND
               (NOT ('AUTOMOTIVE_DESIGN.PRODUCT_IDENTIFICATION' IN
                     TYPEOF(cd.configuration)))
              )) = 0;
              
END_RULE;
(*

Argument definitions:

configuration_design: the set of all instances of configuration_design.

product_class: the set of all instances of product_class.

product_class: the set of all instances of product_class.

Formal propositions

WR1: Each instance of configuration_design which has a name of 'functionality' shall reference as design a product_definition which references as its frame_of_reference a product_definition_context with a name of 'functional definition'.

WR2: Each instance of configuration_design which has a name of 'realization' shall reference as design a product_definition which references as its frame_of_reference a product_definition_context with a name of 'conceptual definition'.

WR3: Each instance of configuration_design which has a name of 'functionality' or 'realization' shall reference as configuration a configuration_item which references as its item_concept a product_class.

WR4: Each instance of configuration_design which has a name of 'design constraint usage' shall reference as design a product_definition which references as its frame_of_reference a product_definition_context with a name of 'design constraint definition'.

WR5: Each instance of configuration_design which has a name of 'physical instance basis' shall reference as design a product_definition which references as its frame_of_reference a product_definition_context with a name of 'physical occurrence'.

WR6: Each instance of configuration_design which has a name of 'physical instance basis' shall reference as configuration a configuration_item of type product_identification.

5.2.4.93 restrict_default_settings

The restrict_default_settings rule ensures that the representation that represents a General_tolerance is unambiguously defined.
*)
RULE restrict_default_settings FOR
    (applied_document_reference,
     representation);
WHERE
  WR1:  (SIZEOF (QUERY (r <* representation |
               (r.name = 'default tolerances') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF(r.items) <> 1)
               )) = 0) AND
             (SIZEOF (QUERY (r <* representation |
               (r.name = 'default tolerances') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF( QUERY( i <* r.items |
                 ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                  TYPEOF(i)) AND
                 (i.name = 'tolerance class')
                 )) <> 1)
               )) = 0);   
  WR2:  SIZEOF (QUERY (r <* representation |
              (r.name = 'default tolerances') AND
              (r.context_of_items.context_type = 'default setting') AND
              (SIZEOF( QUERY( adr <* USEDIN(r,'AUTOMOTIVE_DESIGN.APPLIED_DOCUMENT_REFERENCE.ITEMS') |
                 adr.role.name = 'general tolerance definition'
                 )) + 
               SIZEOF( QUERY( rr <* USEDIN(r,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_2') |
                 (rr.name = 'general tolerance definition') AND
                 ('AUTOMOTIVE_DESIGN.DEFAULT_TOLERANCE_TABLE' IN
                  TYPEOF(rr.rep_1))
                 )) <> 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

applied_document_reference: the set of all instances of applied_document_reference.

representation: the set of all instances of representation.

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of representation that has a name of 'default tolerances' and a representation_context that has a context_type of 'default setting' shall contain exactly one representation_item in its set of items. This representation_item shall be of type descriptive_representation_item and shall have a name of 'tolerance class'.

WR2: Each instance of representation that has a name of 'default tolerances' and a representation_context that has a context_type of 'default setting' shall be refered either by an applied_document_reference with a role that has a name of 'general tolerance definition' or as rep_2 by a representation_relationship with a name of general tolerance definition', where the rep_1 is a default_tolerance_table.

5.2.4.94 restrict_default_thickness

The restrict_default_thickness rule ensures that the representation that represents a Default_thickness is unambiguously defined.
*)
RULE restrict_default_thickness FOR
    (representation);
WHERE
  WR1:  (SIZEOF (QUERY (r <* representation |
               (r.name = 'default thickness') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF( QUERY( i <* r.items |
                 ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                  TYPEOF(i)) 
                 )) > 1) 
               )) = 0) AND
             (SIZEOF (QUERY (r <* representation |
               (r.name = 'default thickness') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF( QUERY( i <* r.items |
                 ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                  TYPEOF(i)) AND
                 (i.name <> 'parameter name')
                 )) > 0)
               )) = 0);   
  WR2:  (SIZEOF (QUERY (r <* representation |
               (r.name = 'default thickness') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF(r.items) > 2)
               )) = 0) AND
             (SIZEOF (QUERY (r <* representation |
               (r.name = 'default thickness') AND
               (r.context_of_items.context_type = 'default setting') AND
               (SIZEOF( QUERY( i <* r.items |
                 (SIZEOF(['AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM',
                          'AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM'] *
                          TYPEOF(i)) <> 1)
                 )) > 0)
               )) = 0);   
  WR3:  SIZEOF (QUERY (r <* representation |
              (r.name = 'default thickness') AND
              (r.context_of_items.context_type = 'default setting') AND
              (SIZEOF( QUERY( i <* r.items |
                ('AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM' IN
                 TYPEOF(i)) AND
                (i.name = 'thickness value')
                )) <> 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of representation that has a name of 'default thickness' and a representation_context that has a context_type of 'default setting' shall contain at most one representation_item in its set of items that is of type descriptive_representation_item. If present, it shall have a name of 'parameter name'.

WR2: Each instance of representation that has a name of 'default thickness' and a representation_context that has a context_type of 'default setting' shall contain at most two representation_item in its set of items. The items shall be of type descriptive_representation_item or measure_representation_item.

WR3: Each instance of representation that has a name of 'default thickness' and a representation_context that has a context_type of 'default setting' shall contain exactly one representation_item in its set of items that is of type measure_representation_item and a name of 'thickness value'.

5.2.4.95 restrict_drawing

The restrict_drawing rule specifies the constraints that apply to a drawing_revision in the context of automotive design.
*)
RULE restrict_drawing FOR
    (draughting_title,
     drawing_revision);
WHERE
  WR1:  -- drawing_requires_sheets:
        (SIZEOF( QUERY( dr <* drawing_revision |
                 (SIZEOF( dr.areas) = 0) OR
                 (SIZEOF( QUERY (ais <* dr.areas | 
                          NOT ('AUTOMOTIVE_DESIGN.DRAWING_SHEET_REVISION' IN
                               TYPEOF (ais.area))
                         )) > 0 )
               )) = 0);      
  WR2:  -- drawing_title:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( USEDIN (dr, 'AUTOMOTIVE_DESIGN.' +
                                    'DRAUGHTING_TITLE.ITEMS')
                      ) > 1
              )) = 0;      
  WR3:  -- sheet_title:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY (ais <* dr.areas |
                        SIZEOF (USEDIN (ais.area,
                                'AUTOMOTIVE_DESIGN.' +
                                'DRAUGHTING_TITLE.ITEMS')
                               ) > 1 )
                       ) > 0
              )) = 0;      
  WR4:  -- allowable_items_of_sheet:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY (ais <* dr.areas |
                        SIZEOF( QUERY (item <* ais.area.items |
                                SIZEOF (TYPEOF(item) *
                                     ['AUTOMOTIVE_DESIGN.STYLED_ITEM',
                                      'AUTOMOTIVE_DESIGN.MAPPED_ITEM',
                                      'AUTOMOTIVE_DESIGN.AXIS2_PLACEMENT',
                                      'AUTOMOTIVE_DESIGN.PLANAR_BOX']
                                     ) <> 1
                              )) > 0
                      )) > 0
              )) = 0;      
  WR5:  -- sheet_contains_view_or_annotation:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY( ais <* dr.areas |
                        SIZEOF( QUERY (item <* ais.area.items |
                                SIZEOF (TYPEOF(item) *
                                   ['AUTOMOTIVE_DESIGN.STYLED_ITEM',
                                    'AUTOMOTIVE_DESIGN.MAPPED_ITEM']) = 0)
                              ) > 0
                      )) > 0)
              ) = 0;      
  WR6:  -- planar_box_in_sheet:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY (ais <* dr.areas |
                     SIZEOF( QUERY( p_b <* QUERY( item <* ais.area.items |
                                           'AUTOMOTIVE_DESIGN.PLANAR_BOX' 
                                           IN TYPEOF(item)) |
                             SIZEOF (USEDIN (p_b, 'AUTOMOTIVE_DESIGN.' +
                                     'PRESENTATION_SIZE.SIZE')
                                       ) <> 1)
                              ) > 0
                      )) > 0
              )) = 0;
              
  WR7:  -- sheets_contain_views:
        SIZEOF( QUERY( dr <* drawing_revision |
         SIZEOF( QUERY (ais <* dr.areas |
          SIZEOF( QUERY (mi <* QUERY(item <* ais.area.items |
                 'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                   IN TYPEOF(item)) |
                 'AUTOMOTIVE_DESIGN.PRESENTATION_VIEW' IN
          TYPEOF(mi\mapped_item.mapping_source.mapped_representation)
                              )) = 0
                      )) > 0
              )) = 0;      
  WR8:  -- sheets_contain_placements:
        SIZEOF( QUERY( dr <* drawing_revision |
          SIZEOF( QUERY (ais <* dr.areas |
             SIZEOF(QUERY(a2p <* QUERY(item <* ais.area.items |
                                'AUTOMOTIVE_DESIGN.AXIS2_PLACEMENT' 
                                 IN TYPEOF(item)) |
                               SIZEOF( USEDIN(a2p,'AUTOMOTIVE_DESIGN.' +
                                       'MAPPED_ITEM.MAPPING_TARGET')) = 0
                              )) > 0
                      )) > 0
              )) = 0;      
  WR9:  -- sheets_have_unique_context:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY (ais <* dr.areas |
                        SIZEOF(ais.area.context_of_items.
                               representations_in_context) > 1
                      )) > 0
              )) = 0;      
  WR10: -- views_presented_once:
        SIZEOF( QUERY( dr <* drawing_revision |
                SIZEOF( QUERY (ais <* dr.areas |
                   SIZEOF( QUERY (mi <* QUERY(item <* ais.area.items |
                                        'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                                        IN TYPEOF(item)) |
         SIZEOF(USEDIN(mi\mapped_item.
        mapping_source.mapped_representation,
                'AUTOMOTIVE_DESIGN.' +
                'REPRESENTATION_MAP.MAPPED_REPRESENTATION')
                                      ) <> 1
                              )) > 0
                      )) > 0
              )) = 0;      
  WR11: -- allowable_items_of_view:
        SIZEOF( QUERY( dr <* drawing_revision |
         SIZEOF( QUERY (ais <* dr.areas |
          SIZEOF( QUERY (mi <* QUERY(item <* ais.area.items |
                    'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                     IN TYPEOF(item)) |
          SIZEOF( QUERY (pv_item <* mi\mapped_item.mapping_source.
                         mapped_representation.items |
            SIZEOF (TYPEOF(pv_item) *
             ['AUTOMOTIVE_DESIGN.STYLED_ITEM',
              'AUTOMOTIVE_DESIGN.CAMERA_IMAGE',
              'AUTOMOTIVE_DESIGN.AXIS2_PLACEMENT']) <> 1)
                                      ) > 0 
                              )) > 0)
                      ) > 0)
              ) = 0;      
  WR12: -- views_contain_one_placement:
        SIZEOF( QUERY( dr <* drawing_revision |
         SIZEOF( QUERY (ais <* dr.areas |
          SIZEOF( QUERY (mi <* QUERY(item <* ais.area.items |
                  'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                  IN TYPEOF(item)) |
         SIZEOF(QUERY
        (a2p <* QUERY(pv_item <* mi\mapped_item.
                                    mapping_source.
                                    mapped_representation.items |
                 'AUTOMOTIVE_DESIGN.AXIS2_PLACEMENT' 
                  IN TYPEOF(pv_item)) |
          SIZEOF(QUERY(rm <* USEDIN(a2p,'AUTOMOTIVE_DESIGN.' +
                       'REPRESENTATION_MAP.MAPPING_ORIGIN') |
          SIZEOF(QUERY (mi <* QUERY(item <* ais.area.items |
                 'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                  IN TYPEOF(item)) |
                  mi\mapped_item.mapping_source :=: rm 
                                                    )) > 0
                                             )) = 1
                                      )) <> 1
                              )) > 0
                      )) > 0
              )) = 0;      
  WR13: -- views_have_unique_context:
        SIZEOF( QUERY( dr <* drawing_revision |
         SIZEOF( QUERY (ais <* dr.areas |
          SIZEOF( QUERY (mi <* QUERY(item <* ais.area.items |
                         'AUTOMOTIVE_DESIGN.MAPPED_ITEM' 
                          IN TYPEOF(item)) |
            SIZEOF(mi\mapped_item.mapping_source.mapped_representation.context_of_items.representations_in_context) <> 1
                              )) > 0
                      )) > 0
              )) = 0;      
END_RULE;
(*

Argument definitions:

draughting_title: the set of all instances of draughting_title.

drawing_revision: the set of all instances of drawing_revision.

drawing_revision: the set of all instances of drawing_revision.

Formal propositions

WR1: Each drawing_revision shall be related to at least one presentation_area, each of which is a drawing_sheet_revision.

WR2: Each drawing_revision shall be one of the items of no more than one draughting_title.

WR3: Each sheet of the drawing_revision shall be one of the items of no more than one draughting_title.

WR4: The items of each sheet of the drawing_revision shall be a styled_item, a mapped_item, an axis2_placement, or a planar_box.

WR5: The items of each sheet of the drawing_revision shall include at least one styled_item or mapped_item.

WR6: Each sheet of the drawing_revision shall contain exactly one planar_box that is the size of a presentation_size.

WR7: If there is a mapped_item in a sheet of the drawing_revision , the source of the mapped_item shall be a presentation_view.

WR8: Every axis2_placement in a sheet of the drawing_revision shall be the mapping_target for some mapped_item.

WR9: The representation_context of a sheet of the drawing_revision shall not be the context of any other representation.

WR10: Each view in a sheet of the drawing_revision shall be the mapped_representation for exactly one mapped_item.

WR11: The items of each view of each sheet of the drawing_revision shall be a styled_item, a camera_image, or an axis2_placement.

WR12: Each view of each sheet of the drawing_revision shall contain exactly one axis2_placement which is the mapping_origin for a mapped_item.

WR13: The representation_context of each view of each sheet of the drawing_revision shall not be the context of any other representation.

5.2.4.96 restrict_effectivity_assignment_for_class_category_usage

The restrict_effectivity_assignment_for_class_category_usage rule restricts the usage of product_concept_feature_category_usage objects in an applied_effectivity_assignment.
*)
RULE restrict_effectivity_assignment_for_class_category_usage FOR
    (applied_effectivity_assignment,
     product_concept_feature_category_usage);
WHERE
 WR1: SIZEOF( QUERY( aea <* applied_effectivity_assignment |
      ((SIZEOF( QUERY( i <* aea.items |
      ('AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE' IN
      TYPEOF(i)) )) > 0) AND ((SIZEOF( QUERY( i <* aea.items |
      ('AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE' IN
      TYPEOF(i)) )) <> SIZEOF(aea.items)) OR
      (SIZEOF(TYPEOF(aea.assigned_effectivity) * 
      ['AUTOMOTIVE_DESIGN.TIME_INTERVAL_BASED_EFFECTIVITY',
       'AUTOMOTIVE_DESIGN.DATED_EFFECTIVITY',
       'AUTOMOTIVE_DESIGN.SERIAL_NUMBERED_EFFECTIVITY',
       'AUTOMOTIVE_DESIGN.LOT_EFFECTIVITY',
       'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_EFFECTIVITY']) > 0) OR
      (aea.assigned_effectivity.id <> 'class usage') OR
      (SIZEOF( QUERY ( cueca <* USEDIN(aea,'AUTOMOTIVE_DESIGN.' +
      'EFFECTIVITY_CONTEXT_ASSIGNMENT.ASSIGNED_EFFECTIVITY_ASSIGNMENT') |
      'AUTOMOTIVE_DESIGN.CLASS_USAGE_EFFECTIVITY_CONTEXT_ASSIGNMENT' 
      IN TYPEOF (cueca ) )) = 0)) ))) = 0;
END_RULE;
(*

Argument definitions:

applied_effectivity_assignment: the set of all instances of applied_effectivity_assignment.

product_concept_feature_category_usage: the set of all instances of product_concept_feature_category_usage.

product_concept_feature_category_usage: the set of all instances of product_concept_feature_category_usage.

Formal propositions

WR1: An applied_effectivity_assignment which has a product_concept_feature_category_usage in its set of items may only have other product_concept_feature_category_usage objects in its set of items. It shall have an assigned_effectivity which is not of an effectivity subtype and which has an id of 'class usage' and it shall be the assigned_effectivity_assignment of a class_usage_effectivity_context_assignment.

5.2.4.97 restrict_effectivity_for_effectivity_relationship

The restrict_effectivity_for_effectivity_relationship rule restricts the types of effectivity that may participate in an effectivity_relationship.
*)
RULE restrict_effectivity_for_effectivity_relationship FOR
    (effectivity_relationship);
WHERE
  WR1:  SIZEOF( QUERY( er <* effectivity_relationship |
               (SIZEOF(['AUTOMOTIVE_DESIGN.LOT_EFFECTIVITY',
                        'AUTOMOTIVE_DESIGN.SERIAL_NUMBERED_EFFECTIVITY',
                        'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_EFFECTIVITY'] *
                        TYPEOF(er.relating_effectivity)) > 0) OR
               (SIZEOF(['AUTOMOTIVE_DESIGN.LOT_EFFECTIVITY',
                        'AUTOMOTIVE_DESIGN.SERIAL_NUMBERED_EFFECTIVITY',
                        'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_EFFECTIVITY'] *
                        TYPEOF(er.related_effectivity)) > 0) 
              )) = 0;   
END_RULE;
(*

Argument definitions:

effectivity_relationship: the set of all instances of effectivity_relationship.

Formal propositions

WR1: The relating_effectivity and the related_effectivity of an effectivity_relationship may not be of type lot_effectivity, serial_numbered_effectivity, or product_definition_effectivity .

5.2.4.98 restrict_effectivity_usage

The restrict_effectivity_usage rule enforces the usage of an effectivity that is not a dated_effectivity or a time_interval_based_effectivity by at least one instance of applied_effectivity_assignment or effectivity_relationship.
*)
RULE restrict_effectivity_usage FOR
    (configured_effectivity_assignment,
     effectivity);
WHERE
  WR1:  SIZEOF( QUERY( e <* effectivity |
                       (SIZEOF(['AUTOMOTIVE_DESIGN.DATED_EFFECTIVITY',
                                'AUTOMOTIVE_DESIGN.TIME_INTERVAL_BASED_EFFECTIVITY'] *
                                TYPEOF(e)) = 0) AND
                       ((SIZEOF( QUERY( er <* USEDIN(e,'AUTOMOTIVE_DESIGN.EFFECTIVITY_RELATIONSHIP.' +
                                 'RELATED_EFFECTIVITY') |
                           er.name = 'inheritance'
                          )) = 0) AND
                        ((e.id = 'configuration validity') AND
                         (SIZEOF( QUERY ( cea <* USEDIN(e,'AUTOMOTIVE_DESIGN.EFFECTIVITY_ASSIGNMENT.ASSIGNED_EFFECTIVITY') |
                           'AUTOMOTIVE_DESIGN.CONFIGURED_EFFECTIVITY_ASSIGNMENT' IN TYPEOF ( cea) )
                           ) = 0)) AND
                        ((e.id = 'class usage') AND
                         (SIZEOF( QUERY( aea <*  USEDIN(e,'AUTOMOTIVE_DESIGN.' +
                                  'EFFECTIVITY_ASSIGNMENT.ASSIGNED_EFFECTIVITY') |
                            ('AUTOMOTIVE_DESIGN.APPLIED_EFFECTIVITY_ASSIGNMENT' IN TYPEOF ( aea ) ) AND
                            (SIZEOF( QUERY( i <* aea.items |
                               'AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE' IN
                               TYPEOF(i)
                              )) > 0)
                           )) = 0)))
                      )) = 0;
END_RULE;
(*

Argument definitions:

configured_effectivity_assignment: the set of all instances of configured_effectivity_assignment.

effectivity: the set of all instances of effectivity.

effectivity: the set of all instances of effectivity.

Formal propositions

WR1: An effectivity that is not a dated_effectivity or a time_interval_based_effectivity, shall either be used at least once as the related_effectivity by an effectivity_relationship with a name of 'inheritance', or it shall have an id of 'configuration validity' and be the assigned_effectivity of a configured_effectivity_assignment or it shall have an id of 'class usage' and be the assigned_effectivity of an applied_effectivity_assignment which has a product_concept_feature_category_usage in its set of items.

5.2.4.99 restrict_externally_defined_item_relationship

The restrict_externally_defined_item_relationship rule ensures the correct correlation between the name of an externally_defined_item_relationship and the related externally_defined_items.
*)
RULE restrict_externally_defined_item_relationship FOR
    (externally_defined_item_relationship);
WHERE
  WR1:  SIZEOF( QUERY( edir <* externally_defined_item_relationship |
               (edir.name = 'name scope') AND
               (NOT('AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_GENERAL_PROPERTY' IN
                    TYPEOF(edir.relating_item)) OR
                NOT('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                    TYPEOF(edir.relating_item.source)) OR
                NOT('AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS' IN
                    TYPEOF(edir.related_item)) OR
                NOT('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN
                    TYPEOF(edir.related_item.source)))
               )) = 0;
           
END_RULE;
(*

Argument definitions:

externally_defined_item_relationship: the set of all instances of externally_defined_item_relationship.

Formal propositions

WR1: If an externally_defined_item_relationship has a name of 'name scope', the relating_item shall be of type externally_defined_general_property and shall reference as the source a known_source and the related_item shall be of type externally_defined_class and shall reference as its source a known_source.

5.2.4.100 restrict_group_relationship_for_general_classification_hierarchy

The restrict_group_relationship_for_general_classification_hierarchy rule ensures the correct correlation between the name of a group_relationship and the related groups of type class.
*)
RULE restrict_group_relationship_for_general_classification_hierarchy FOR
    (class,
     group_relationship);
WHERE
  WR1:  SIZEOF( QUERY( gr <* group_relationship |
               (gr.name = 'class hierarchy') AND
               (NOT('AUTOMOTIVE_DESIGN.CLASS' IN TYPEOF(gr.related_group)) OR
                NOT('AUTOMOTIVE_DESIGN.CLASS' IN TYPEOF(gr.relating_group)))
              )) = 0;
           
END_RULE;
(*

Argument definitions:

class: the set of all instances of class.

group_relationship: the set of all instances of group_relationship.

group_relationship: the set of all instances of group_relationship.

Formal propositions

WR1: If the group_relationship has a name of 'class hierarchy', the related_group and the relating_group shall be of type class.

5.2.4.101 restrict_group_relationship_for_specification_category

The restrict_group_relationship_for_specification_category rule ensures the correct correlation between the name of a group_relationship and the related groups of type product_concept_feature_category.
*)
RULE restrict_group_relationship_for_specification_category FOR
    (group_relationship,
     product_concept_feature_category);
WHERE
  WR1:  SIZEOF( QUERY( gr <* group_relationship |
               (gr.name = 'specification category hierarchy') AND
               (NOT('AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN
                    TYPEOF(gr.related_group)) OR
                NOT('AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN
                    TYPEOF(gr.relating_group)))
              )) = 0;
              
END_RULE;
(*

Argument definitions:

group_relationship: the set of all instances of group_relationship.

product_concept_feature_category: the set of all instances of product_concept_feature_category.

product_concept_feature_category: the set of all instances of product_concept_feature_category.

Formal propositions

WR1: If the group_relationship has a name of 'specification category hierarchy', the related_group and the relating_group shall be of type product_concept_feature_category.

5.2.4.102 restrict_multi_language_for_action

The restrict_multi_language_for_action rule specifies that each instance of action shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_action FOR
    (action);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* action |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* action | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

action: the set of all instances of action.

Formal propositions

WR1: Each instance of action shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of action shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of action, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.103 restrict_multi_language_for_action_directive

The restrict_multi_language_for_action_directive rule specifies that each instance of action_directive shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'comment'.
*)
RULE restrict_multi_language_for_action_directive FOR
    (action_directive);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_directive |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'comment'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* action_directive |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'comment'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* action_directive | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_directive: the set of all instances of action_directive.

Formal propositions

WR1: Each instance of action_directive shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'comment'.

WR2: Each instance of action_directive shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'comment'.

WR3: For each instance of action_directive, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.104 restrict_multi_language_for_action_method

The restrict_multi_language_for_action_method rule specifies that each instance of action_method shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_action_method FOR
    (action_method);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_method |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* action_method |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* action_method | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_method: the set of all instances of action_method.

Formal propositions

WR1: Each instance of action_method shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of action_method shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of action_method, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.105 restrict_multi_language_for_action_property

The restrict_multi_language_for_action_property rule specifies that each instance of action_property shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_action_property FOR
    (action_property);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_property |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* action_property |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* action_property | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_property: the set of all instances of action_property.

Formal propositions

WR1: Each instance of action_property shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of action_property shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of action_property, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.106 restrict_multi_language_for_action_relationship

The restrict_multi_language_for_action_relationship rule specifies that each instance of action_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_action_relationship FOR
    (action_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* action_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* action_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_relationship: the set of all instances of action_relationship.

Formal propositions

WR1: Each instance of action_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of action_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of action_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.107 restrict_multi_language_for_alternate_product_relationship

The restrict_multi_language_for_alternate_product_relationship rule specifies that each instance of alternate_product_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'basis'.
*)
RULE restrict_multi_language_for_alternate_product_relationship FOR
    (alternate_product_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* alternate_product_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'basis'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* alternate_product_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'basis'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* alternate_product_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

alternate_product_relationship: the set of all instances of alternate_product_relationship.

Formal propositions

WR1: Each instance of alternate_product_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'basis'.

WR2: Each instance of alternate_product_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'basis'.

WR3: For each instance of alternate_product_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.108 restrict_multi_language_for_application_context

The restrict_multi_language_for_application_context rule specifies that each instance of application_context shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_application_context FOR
    (application_context);
WHERE
  WR1:  SIZEOF(QUERY(ent <* application_context |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* application_context |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* application_context | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

application_context: the set of all instances of application_context.

Formal propositions

WR1: Each instance of application_context shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of application_context shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of application_context, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.109 restrict_multi_language_for_approval_relationship

The restrict_multi_language_for_approval_relationship rule specifies that each instance of approval_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_approval_relationship FOR
    (approval_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* approval_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* approval_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* approval_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

approval_relationship: the set of all instances of approval_relationship.

Formal propositions

WR1: Each instance of approval_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of approval_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of approval_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.110 restrict_multi_language_for_assembly_component_usage_substitute

The restrict_multi_language_for_assembly_component_usage_substitute rule specifies that each instance of assembly_component_usage_substitute shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'definition'.
*)
RULE restrict_multi_language_for_assembly_component_usage_substitute FOR
    (assembly_component_usage_substitute);
WHERE
  WR1:  SIZEOF(QUERY(ent <* assembly_component_usage_substitute |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'definition'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* assembly_component_usage_substitute |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'definition'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* assembly_component_usage_substitute | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

assembly_component_usage_substitute: the set of all instances of assembly_component_usage_substitute.

Formal propositions

WR1: Each instance of assembly_component_usage_substitute shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'definition'.

WR2: Each instance of assembly_component_usage_substitute shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'definition'.

WR3: For each instance of assembly_component_usage_substitute, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.111 restrict_multi_language_for_certification

The restrict_multi_language_for_certification rule specifies that each instance of certification shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'name' or 'purpose'.
*)
RULE restrict_multi_language_for_certification FOR
    (certification);
WHERE
  WR1:  SIZEOF(QUERY(ent <* certification |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name') AND
                (mlaa.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* certification |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name') AND
                (ala.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* certification | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

certification: the set of all instances of certification.

Formal propositions

WR1: Each instance of certification shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'name' or 'purpose'.

WR2: Each instance of certification shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'name' or 'purpose'.

WR3: For each instance of certification, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.112 restrict_multi_language_for_configuration_design

The restrict_multi_language_for_configuration_design rule specifies that each instance of configuration_design shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_configuration_design FOR
    (configuration_design);
WHERE
  WR1:  SIZEOF(QUERY(ent <* configuration_design |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* configuration_design |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* configuration_design | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

configuration_design: the set of all instances of configuration_design.

Formal propositions

WR1: Each instance of configuration_design shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of configuration_design shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of configuration_design, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.113 restrict_multi_language_for_configuration_item

The restrict_multi_language_for_configuration_item rule specifies that each instance of configuration_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_configuration_item FOR
    (configuration_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* configuration_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* configuration_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* configuration_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

configuration_item: the set of all instances of configuration_item.

Formal propositions

WR1: Each instance of configuration_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of configuration_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of configuration_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.114 restrict_multi_language_for_contract

The restrict_multi_language_for_contract rule specifies that each instance of contract shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'purpose'.
*)
RULE restrict_multi_language_for_contract FOR
    (contract);
WHERE
  WR1:  SIZEOF(QUERY(ent <* contract |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* contract |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* contract | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

contract: the set of all instances of contract.

Formal propositions

WR1: Each instance of contract shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'purpose'.

WR2: Each instance of contract shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'purpose'.

WR3: For each instance of contract, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.115 restrict_multi_language_for_data_environment

The restrict_multi_language_for_data_environment rule specifies that each instance of data_environment shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_data_environment FOR
    (data_environment);
WHERE
  WR1:  SIZEOF(QUERY(ent <* data_environment |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* data_environment |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* data_environment | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

data_environment: the set of all instances of data_environment.

Formal propositions

WR1: Each instance of data_environment shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of data_environment shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of data_environment, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.116 restrict_multi_language_for_date_role

The restrict_multi_language_for_date_role rule specifies that each instance of date_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_date_role FOR
    (date_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* date_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* date_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* date_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

date_role: the set of all instances of date_role.

Formal propositions

WR1: Each instance of date_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of date_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of date_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.117 restrict_multi_language_for_date_time_role

The restrict_multi_language_for_date_time_role rule specifies that each instance of date_time_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_date_time_role FOR
    (date_time_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* date_time_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* date_time_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* date_time_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

date_time_role: the set of all instances of date_time_role.

Formal propositions

WR1: Each instance of date_time_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of date_time_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of date_time_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.118 restrict_multi_language_for_descriptive_representation_item

The restrict_multi_language_for_descriptive_representation_item rule specifies that each instance of descriptive_representation_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_descriptive_representation_item FOR
    (descriptive_representation_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* descriptive_representation_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* descriptive_representation_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* descriptive_representation_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

descriptive_representation_item: the set of all instances of descriptive_representation_item.

Formal propositions

WR1: Each instance of descriptive_representation_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of descriptive_representation_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of descriptive_representation_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.119 restrict_multi_language_for_document_relationship

The restrict_multi_language_for_document_relationship rule specifies that each instance of document_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_document_relationship FOR
    (document_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* document_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* document_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* document_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

document_relationship: the set of all instances of document_relationship.

Formal propositions

WR1: Each instance of document_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of document_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of document_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.120 restrict_multi_language_for_draughting_title

The restrict_multi_language_for_draughting_title rule specifies that each instance of draughting_title shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'contents'. For the attribute_language_assignment, a name of 'language' is allowed additionally.
*)
RULE restrict_multi_language_for_draughting_title FOR
    (draughting_title);
WHERE
  WR1:  SIZEOF(QUERY(ent <* draughting_title |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'contents'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* draughting_title |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'contents') AND
                (ala.attribute_name <> 'language'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* draughting_title | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

draughting_title: the set of all instances of draughting_title.

Formal propositions

WR1: Each instance of draughting_title shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of ''.

WR2: Each instance of draughting_title shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'contents' or 'language'.

WR3: For each instance of draughting_title, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.121 restrict_multi_language_for_effectivity

The restrict_multi_language_for_effectivity rule specifies that each instance of effectivity shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_effectivity FOR
    (effectivity);
WHERE
  WR1:  SIZEOF(QUERY(ent <* effectivity |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* effectivity |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* effectivity | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

effectivity: the set of all instances of effectivity.

Formal propositions

WR1: Each instance of effectivity shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of effectivity shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of effectivity, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.122 restrict_multi_language_for_effectivity_relationship

The restrict_multi_language_for_effectivity_relationship rule specifies that each instance of effectivity_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_effectivity_relationship FOR
    (effectivity_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* effectivity_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* effectivity_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* effectivity_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

effectivity_relationship: the set of all instances of effectivity_relationship.

Formal propositions

WR1: Each instance of effectivity_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of effectivity_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of effectivity_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.123 restrict_multi_language_for_event_occurrence

The restrict_multi_language_for_event_occurrence rule specifies that each instance of event_occurrence shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_event_occurrence FOR
    (event_occurrence);
WHERE
  WR1:  SIZEOF(QUERY(ent <* event_occurrence |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* event_occurrence |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* event_occurrence | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

event_occurrence: the set of all instances of event_occurrence.

Formal propositions

WR1: Each instance of event_occurrence shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of event_occurrence shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of event_occurrence, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.124 restrict_multi_language_for_external_source

The restrict_multi_language_for_external_source rule specifies that each instance of external_source shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_external_source FOR
    (external_source);
WHERE
  WR1:  SIZEOF(QUERY(ent <* external_source |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* external_source |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* external_source | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

external_source: the set of all instances of external_source.

Formal propositions

WR1: Each instance of external_source shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of external_source shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of external_source, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.125 restrict_multi_language_for_general_property

The restrict_multi_language_for_general_property rule specifies that each instance of general_property shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_general_property FOR
    (general_property);
WHERE
  WR1:  SIZEOF(QUERY(ent <* general_property |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* general_property |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* general_property | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

general_property: the set of all instances of general_property.

Formal propositions

WR1: Each instance of general_property shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of general_property shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of general_property, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.126 restrict_multi_language_for_general_property_relationship

The restrict_multi_language_for_general_property_relationship rule specifies that each instance of general_property_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_general_property_relationship FOR
    (general_property_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* general_property_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* general_property_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* general_property_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

general_property_relationship: the set of all instances of general_property_relationship.

Formal propositions

WR1: Each instance of general_property_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of general_property_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of general_property_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.127 restrict_multi_language_for_geometric_representation_item

The restrict_multi_language_for_geometric_representation_item rule specifies that each instance of geometric_representation_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_geometric_representation_item FOR
    (geometric_representation_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* geometric_representation_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* geometric_representation_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* geometric_representation_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

geometric_representation_item: the set of all instances of geometric_representation_item.

Formal propositions

WR1: Each instance of geometric_representation_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of geometric_representation_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of geometric_representation_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.128 restrict_multi_language_for_geometric_tolerance

The restrict_multi_language_for_geometric_tolerance rule specifies that each instance of geometric_tolerance shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_geometric_tolerance FOR
    (geometric_tolerance);
WHERE
  WR1:  SIZEOF(QUERY(ent <* geometric_tolerance |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* geometric_tolerance |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* geometric_tolerance | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

geometric_tolerance: the set of all instances of geometric_tolerance.

Formal propositions

WR1: Each instance of geometric_tolerance shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of geometric_tolerance shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of geometric_tolerance, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.129 restrict_multi_language_for_group

The restrict_multi_language_for_group rule specifies that each instance of group shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_group FOR
    (group);
WHERE
  WR1:  SIZEOF(QUERY(ent <* group |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* group |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* group | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

group: the set of all instances of group.

Formal propositions

WR1: Each instance of group shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of group shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of group, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.130 restrict_multi_language_for_group_relationship

The restrict_multi_language_for_group_relationship rule specifies that each instance of group_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_group_relationship FOR
    (group_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* group_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* group_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* group_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

group_relationship: the set of all instances of group_relationship.

Formal propositions

WR1: Each instance of group_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of group_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of group_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.131 restrict_multi_language_for_identification_role

The restrict_multi_language_for_identification_role rule specifies that each instance of identification_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_identification_role FOR
    (identification_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* identification_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* identification_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* identification_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

identification_role: the set of all instances of identification_role.

Formal propositions

WR1: Each instance of identification_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of identification_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of identification_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.132 restrict_multi_language_for_kinematic_pair

The restrict_multi_language_for_kinematic_pair rule specifies that each instance of kinematic_pair shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_kinematic_pair FOR
    (kinematic_pair);
WHERE
  WR1:  SIZEOF(QUERY(ent <* kinematic_pair |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* kinematic_pair |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* kinematic_pair | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

kinematic_pair: the set of all instances of kinematic_pair.

Formal propositions

WR1: Each instance of kinematic_pair shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of kinematic_pair shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of kinematic_pair, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.133 restrict_multi_language_for_mapped_item

The restrict_multi_language_for_mapped_item rule specifies that each instance of mapped_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_mapped_item FOR
    (mapped_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* mapped_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* mapped_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* mapped_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

mapped_item: the set of all instances of mapped_item.

Formal propositions

WR1: Each instance of mapped_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of mapped_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of mapped_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.134 restrict_multi_language_for_name_assignment

The restrict_multi_language_for_name_assignment rule specifies that each instance of name_assignment shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'assigned_name'.
*)
RULE restrict_multi_language_for_name_assignment FOR
    (name_assignment);
WHERE
  WR1:  SIZEOF(QUERY(ent <* name_assignment |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'assigned_name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* name_assignment |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'assigned_name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* name_assignment | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

name_assignment: the set of all instances of name_assignment.

Formal propositions

WR1: Each instance of name_assignment shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'assigned_name'.

WR2: Each instance of name_assignment shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'assigned_name'.

WR3: For each instance of name_assignment, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.135 restrict_multi_language_for_organization_relationship

The restrict_multi_language_for_organization_relationship rule specifies that each instance of organization_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_organization_relationship FOR
    (organization_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* organization_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* organization_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* organization_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

organization_relationship: the set of all instances of organization_relationship.

Formal propositions

WR1: Each instance of organization_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of organization_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of organization_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.136 restrict_multi_language_for_organization_role

The restrict_multi_language_for_organization_role rule specifies that each instance of organization_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_organization_role FOR
    (organization_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* organization_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* organization_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* organization_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

organization_role: the set of all instances of organization_role.

Formal propositions

WR1: Each instance of organization_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of organization_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of organization_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.137 restrict_multi_language_for_organizational_project

The restrict_multi_language_for_organizational_project rule specifies that each instance of organizational_project shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_organizational_project FOR
    (organizational_project);
WHERE
  WR1:  SIZEOF(QUERY(ent <* organizational_project |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* organizational_project |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* organizational_project | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

organizational_project: the set of all instances of organizational_project.

Formal propositions

WR1: Each instance of organizational_project shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of organizational_project shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of organizational_project, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.138 restrict_multi_language_for_organizational_project_relationship

The restrict_multi_language_for_organizational_project_relationship rule specifies that each instance of organizational_project_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_organizational_project_relationship FOR
    (organizational_project_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* organizational_project_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* organizational_project_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* organizational_project_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

organizational_project_relationship: the set of all instances of organizational_project_relationship.

Formal propositions

WR1: Each instance of organizational_project_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of organizational_project_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of organizational_project_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.139 restrict_multi_language_for_pair_actuator

The restrict_multi_language_for_pair_actuator rule specifies that each instance of pair_actuator shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_pair_actuator FOR
    (pair_actuator);
WHERE
  WR1:  SIZEOF(QUERY(ent <* pair_actuator |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* pair_actuator |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* pair_actuator | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

pair_actuator: the set of all instances of pair_actuator.

Formal propositions

WR1: Each instance of pair_actuator shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of pair_actuator shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of pair_actuator, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.140 restrict_multi_language_for_person_and_organization_role

The restrict_multi_language_for_person_and_organization_role rule specifies that each instance of person_and_organization_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_person_and_organization_role FOR
    (person_and_organization_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* person_and_organization_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* person_and_organization_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* person_and_organization_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

person_and_organization_role: the set of all instances of person_and_organization_role.

Formal propositions

WR1: Each instance of person_and_organization_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of person_and_organization_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of person_and_organization_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.141 restrict_multi_language_for_presentation_layer_assignment

The restrict_multi_language_for_presentation_layer_assignment rule specifies that each instance of presentation_layer_assignment shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_presentation_layer_assignment FOR
    (presentation_layer_assignment);
WHERE
  WR1:  SIZEOF(QUERY(ent <* presentation_layer_assignment |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* presentation_layer_assignment |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* presentation_layer_assignment | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

presentation_layer_assignment: the set of all instances of presentation_layer_assignment.

Formal propositions

WR1: Each instance of presentation_layer_assignment shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of presentation_layer_assignment shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of presentation_layer_assignment, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.142 restrict_multi_language_for_process_product_association

The restrict_multi_language_for_process_product_association rule specifies that each instance of process_product_association shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_process_product_association FOR
    (process_product_association);
WHERE
  WR1:  SIZEOF(QUERY(ent <* process_product_association |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* process_product_association |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* process_product_association | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

process_product_association: the set of all instances of process_product_association.

Formal propositions

WR1: Each instance of process_product_association shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of process_product_association shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of process_product_association, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.143 restrict_multi_language_for_product

The restrict_multi_language_for_product rule specifies that each instance of product shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_product FOR
    (product);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product: the set of all instances of product.

Formal propositions

WR1: Each instance of product shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of product shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of product, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.144 restrict_multi_language_for_product_concept

The restrict_multi_language_for_product_concept rule specifies that each instance of product_concept shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_product_concept FOR
    (product_concept);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_concept |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_concept | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept: the set of all instances of product_concept.

Formal propositions

WR1: Each instance of product_concept shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of product_concept shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of product_concept, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.145 restrict_multi_language_for_product_concept_feature

The restrict_multi_language_for_product_concept_feature rule specifies that each instance of product_concept_feature shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_product_concept_feature FOR
    (product_concept_feature);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept_feature |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_concept_feature |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_concept_feature | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept_feature: the set of all instances of product_concept_feature.

Formal propositions

WR1: Each instance of product_concept_feature shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of product_concept_feature shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of product_concept_feature, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.146 restrict_multi_language_for_product_concept_feature_association

The restrict_multi_language_for_product_concept_feature_association rule specifies that each instance of product_concept_feature_association shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_concept_feature_association FOR
    (product_concept_feature_association);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept_feature_association |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_concept_feature_association |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_concept_feature_association | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept_feature_association: the set of all instances of product_concept_feature_association.

Formal propositions

WR1: Each instance of product_concept_feature_association shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_concept_feature_association shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_concept_feature_association, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.147 restrict_multi_language_for_product_concept_relationship

The restrict_multi_language_for_product_concept_relationship rule specifies that each instance of product_concept_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_concept_relationship FOR
    (product_concept_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_concept_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_concept_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept_relationship: the set of all instances of product_concept_relationship.

Formal propositions

WR1: Each instance of product_concept_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_concept_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_concept_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.148 restrict_multi_language_for_product_definition

The restrict_multi_language_for_product_definition rule specifies that each instance of product_definition shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_product_definition FOR
    (product_definition);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_definition |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_definition |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_definition | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

Formal propositions

WR1: Each instance of product_definition shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of product_definition shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of product_definition, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.149 restrict_multi_language_for_product_definition_formation

The restrict_multi_language_for_product_definition_formation rule specifies that each instance of product_definition_formation shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_definition_formation FOR
    (product_definition_formation);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_definition_formation |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_definition_formation |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_definition_formation | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_definition_formation: the set of all instances of product_definition_formation.

Formal propositions

WR1: Each instance of product_definition_formation shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_definition_formation shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_definition_formation, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.150 restrict_multi_language_for_product_definition_formation_relationship

The restrict_multi_language_for_product_definition_formation_relationship rule specifies that each instance of product_definition_formation_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_definition_formation_relationship FOR
    (product_definition_formation_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_definition_formation_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_definition_formation_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_definition_formation_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_definition_formation_relationship: the set of all instances of product_definition_formation_relationship.

Formal propositions

WR1: Each instance of product_definition_formation_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_definition_formation_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_definition_formation_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.151 restrict_multi_language_for_product_definition_relationship

The restrict_multi_language_for_product_definition_relationship rule specifies that each instance of product_definition_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_definition_relationship FOR
    (product_definition_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_definition_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_definition_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_definition_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_definition_relationship: the set of all instances of product_definition_relationship.

Formal propositions

WR1: Each instance of product_definition_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_definition_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_definition_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.152 restrict_multi_language_for_product_definition_substitute

The restrict_multi_language_for_product_definition_substitute rule specifies that each instance of product_definition_substitute shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_definition_substitute FOR
    (product_definition_substitute);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_definition_substitute |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_definition_substitute |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_definition_substitute | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_definition_substitute: the set of all instances of product_definition_substitute.

Formal propositions

WR1: Each instance of product_definition_substitute shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_definition_substitute shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_definition_substitute, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.153 restrict_multi_language_for_product_related_product_category

The restrict_multi_language_for_product_related_product_category rule specifies that each instance of product_related_product_category shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_product_related_product_category FOR
    (product_related_product_category);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_related_product_category |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* product_related_product_category |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* product_related_product_category | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_related_product_category: the set of all instances of product_related_product_category.

Formal propositions

WR1: Each instance of product_related_product_category shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of product_related_product_category shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of product_related_product_category, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.154 restrict_multi_language_for_property_definition

The restrict_multi_language_for_property_definition rule specifies that each instance of property_definition shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_property_definition FOR
    (property_definition);
WHERE
  WR1:  SIZEOF(QUERY(ent <* property_definition |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* property_definition |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* property_definition | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

property_definition: the set of all instances of property_definition.

Formal propositions

WR1: Each instance of property_definition shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of property_definition shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of property_definition, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.155 restrict_multi_language_for_property_definition_relationship

The restrict_multi_language_for_property_definition_relationship rule specifies that each instance of property_definition_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_property_definition_relationship FOR
    (property_definition_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* property_definition_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* property_definition_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* property_definition_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

property_definition_relationship: the set of all instances of property_definition_relationship.

Formal propositions

WR1: Each instance of property_definition_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of property_definition_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of property_definition_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.156 restrict_multi_language_for_representation

The restrict_multi_language_for_representation rule specifies that each instance of representation shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.
*)
RULE restrict_multi_language_for_representation FOR
    (representation);
WHERE
  WR1:  SIZEOF(QUERY(ent <* representation |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description') AND
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* representation |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description') AND
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* representation | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of representation shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR2: Each instance of representation shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'description' or 'name'.

WR3: For each instance of representation, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.157 restrict_multi_language_for_representation_relationship

The restrict_multi_language_for_representation_relationship rule specifies that each instance of representation_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_representation_relationship FOR
    (representation_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* representation_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* representation_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* representation_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

representation_relationship: the set of all instances of representation_relationship.

Formal propositions

WR1: Each instance of representation_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of representation_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of representation_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.158 restrict_multi_language_for_requirement_for_action_resource

The restrict_multi_language_for_requirement_for_action_resource rule specifies that each instance of requirement_for_action_resource shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_requirement_for_action_resource FOR
    (requirement_for_action_resource);
WHERE
  WR1:  SIZEOF(QUERY(ent <* requirement_for_action_resource |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* requirement_for_action_resource |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* requirement_for_action_resource | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

requirement_for_action_resource: the set of all instances of requirement_for_action_resource.

Formal propositions

WR1: Each instance of requirement_for_action_resource shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of requirement_for_action_resource shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of requirement_for_action_resource, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.159 restrict_multi_language_for_resource_property

The restrict_multi_language_for_resource_property rule specifies that each instance of resource_property shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_resource_property FOR
    (resource_property);
WHERE
  WR1:  SIZEOF(QUERY(ent <* resource_property |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* resource_property |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* resource_property | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

resource_property: the set of all instances of resource_property.

Formal propositions

WR1: Each instance of resource_property shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of resource_property shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of resource_property, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.160 restrict_multi_language_for_resource_requirement_type

The restrict_multi_language_for_resource_requirement_type rule specifies that each instance of resource_requirement_type shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_resource_requirement_type FOR
    (resource_requirement_type);
WHERE
  WR1:  SIZEOF(QUERY(ent <* resource_requirement_type |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* resource_requirement_type |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* resource_requirement_type | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

resource_requirement_type: the set of all instances of resource_requirement_type.

Formal propositions

WR1: Each instance of resource_requirement_type shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of resource_requirement_type shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of resource_requirement_type, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.161 restrict_multi_language_for_security_classification

The restrict_multi_language_for_security_classification rule specifies that each instance of security_classification shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of either 'name' or 'purpose'.
*)
RULE restrict_multi_language_for_security_classification FOR
    (security_classification);
WHERE
  WR1:  SIZEOF(QUERY(ent <* security_classification |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name') AND
                (mlaa.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* security_classification |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name') AND
                (ala.attribute_name <> 'purpose'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* security_classification | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

security_classification: the set of all instances of security_classification.

Formal propositions

WR1: Each instance of security_classification shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of either 'name' or 'purpose'.

WR2: Each instance of security_classification shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of either 'name' or 'purpose'.

WR3: For each instance of security_classification, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.162 restrict_multi_language_for_shape_aspect

The restrict_multi_language_for_shape_aspect rule specifies that each instance of shape_aspect shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_shape_aspect FOR
    (shape_aspect);
WHERE
  WR1:  SIZEOF(QUERY(ent <* shape_aspect |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* shape_aspect |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* shape_aspect | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

shape_aspect: the set of all instances of shape_aspect.

Formal propositions

WR1: Each instance of shape_aspect shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of shape_aspect shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of shape_aspect, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.163 restrict_multi_language_for_shape_aspect_relationship

The restrict_multi_language_for_shape_aspect_relationship rule specifies that each instance of shape_aspect_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_shape_aspect_relationship FOR
    (shape_aspect_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* shape_aspect_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* shape_aspect_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* shape_aspect_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

shape_aspect_relationship: the set of all instances of shape_aspect_relationship.

Formal propositions

WR1: Each instance of shape_aspect_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of shape_aspect_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of shape_aspect_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.164 restrict_multi_language_for_styled_item

The restrict_multi_language_for_styled_item rule specifies that each instance of styled_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_styled_item FOR
    (styled_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* styled_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* styled_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* styled_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

styled_item: the set of all instances of styled_item.

Formal propositions

WR1: Each instance of styled_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of styled_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of styled_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.165 restrict_multi_language_for_time_interval_role

The restrict_multi_language_for_time_interval_role rule specifies that each instance of time_interval_role shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_time_interval_role FOR
    (time_interval_role);
WHERE
  WR1:  SIZEOF(QUERY(ent <* time_interval_role |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* time_interval_role |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* time_interval_role | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

time_interval_role: the set of all instances of time_interval_role.

Formal propositions

WR1: Each instance of time_interval_role shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of time_interval_role shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of time_interval_role, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.166 restrict_multi_language_for_topological_representation_item

The restrict_multi_language_for_topological_representation_item rule specifies that each instance of topological_representation_item shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'name'.
*)
RULE restrict_multi_language_for_topological_representation_item FOR
    (topological_representation_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* topological_representation_item |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* topological_representation_item |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'name'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* topological_representation_item | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

topological_representation_item: the set of all instances of topological_representation_item.

Formal propositions

WR1: Each instance of topological_representation_item shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'name'.

WR2: Each instance of topological_representation_item shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'name'.

WR3: For each instance of topological_representation_item, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.167 restrict_multi_language_for_uncertainty_measure_with_unit

The restrict_multi_language_for_uncertainty_measure_with_unit rule specifies that each instance of uncertainty_measure_with_unit shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_uncertainty_measure_with_unit FOR
    (uncertainty_measure_with_unit);
WHERE
  WR1:  SIZEOF(QUERY(ent <* uncertainty_measure_with_unit |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* uncertainty_measure_with_unit |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* uncertainty_measure_with_unit | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

uncertainty_measure_with_unit: the set of all instances of uncertainty_measure_with_unit.

Formal propositions

WR1: Each instance of uncertainty_measure_with_unit shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of uncertainty_measure_with_unit shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of uncertainty_measure_with_unit, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.168 restrict_multi_language_for_uncertainty_qualifier

The restrict_multi_language_for_uncertainty_qualifier rule specifies that each instance of uncertainty_qualifier shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_uncertainty_qualifier FOR
    (uncertainty_qualifier);
WHERE
  WR1:  SIZEOF(QUERY(ent <* uncertainty_qualifier |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* uncertainty_qualifier |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* uncertainty_qualifier | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

uncertainty_qualifier: the set of all instances of uncertainty_qualifier.

Formal propositions

WR1: Each instance of uncertainty_qualifier shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of uncertainty_qualifier shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of uncertainty_qualifier, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.169 restrict_multi_language_for_versioned_action_request

The restrict_multi_language_for_versioned_action_request rule specifies that each instance of versioned_action_request shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.
*)
RULE restrict_multi_language_for_versioned_action_request FOR
    (versioned_action_request);
WHERE
  WR1:  SIZEOF(QUERY(ent <* versioned_action_request |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* versioned_action_request |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* versioned_action_request | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions:

versioned_action_request: the set of all instances of versioned_action_request.

Formal propositions

WR1: Each instance of versioned_action_request shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'.

WR2: Each instance of versioned_action_request shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of versioned_action_request, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.170 restrict_multi_language_for_versioned_action_request_relationship

The restrict_multi_language_for_versioned_action_request_relationship rule specifies that each instance of versioned_action_request_relationship shall only be referenced by instances of multi_language_attribute_assignment or attribute_language_assignment that have an attribute attribute_name of 'description'.

*)
RULE restrict_multi_language_for_versioned_action_request_relationship FOR
    (versioned_action_request_relationship);
WHERE
  WR1:  SIZEOF(QUERY(ent <* versioned_action_request_relationship |
         SIZEOF(QUERY(mlaa <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR2:  SIZEOF(QUERY(ent <* versioned_action_request_relationship |
         SIZEOF(QUERY(ala <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala.attribute_name <> 'description'))) > 0)
              ) = 0;
  WR3:  SIZEOF(QUERY(ent <* versioned_action_request_relationship | 
               (SIZEOF(QUERY(mlaa1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(mlaa2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
                (mlaa1.attribute_name = mlaa2.attribute_name) AND
                (mlaa1.language = mlaa2.language))) > 1 )) +
                SIZEOF(QUERY(ala1 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
               'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                SIZEOF(QUERY(ala2 <* USEDIN(ent,'AUTOMOTIVE_DESIGN.' +
                'ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
                (ala1.attribute_name = ala2.attribute_name) AND
                (ala1.language = ala2.language))) > 1 ))) > 0)
              ) = 0;
END_RULE;
(*

Argument definitions: versioned_action_request_relationship: the set of all instances of versioned_action_request_relationship. Formal propositions WR1: Each instance of versioned_action_request_relationship shall be only in the set of items of those instances of multi_language_attribute_assignment that have an attribute attribute_name of 'description'. WR2: Each instance of versioned_action_request_relationship shall be only in the set of items of those instances of attribute_language_assignment that have an attribute attribute_name of 'description'.

WR3: For each instance of versioned_action_request_relationship, there shall not be more than one multi_language_attribute_assignment or attribute_language_assignment with the same language and the same attribute_name.

5.2.4.171 restrict_name_assignment_for_kinematic_joint

The restrict_name_assignment_for_kinematic_joint rule specifies that each instance of kinematic_joint shall be referenced by at most one instance of applied_name_assignment.
*)
RULE restrict_name_assignment_for_kinematic_joint FOR
    (kinematic_joint);
WHERE
  WR1:  SIZEOF(QUERY(ent <* kinematic_joint |
          SIZEOF( USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_NAME_ASSIGNMENT.ITEMS')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

kinematic_joint: the set of all instances of kinematic_joint.

Formal propositions

WR1: For each instance of kinematic_joint there shall be only at most one instance of applied_name_assignment.

5.2.4.172 restrict_name_assignment_for_kinematic_link

The restrict_name_assignment_for_kinematic_link rule specifies that each instance of kinematic_link shall be referenced by at most one instance of applied_name_assignment.
*)
RULE restrict_name_assignment_for_kinematic_link FOR
    (kinematic_link);
WHERE
  WR1:  SIZEOF(QUERY(ent <* kinematic_link |
          SIZEOF( USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_NAME_ASSIGNMENT.ITEMS')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

kinematic_link: the set of all instances of kinematic_link.

Formal propositions

WR1: For each instance of kinematic_link there shall be only at most one instance of applied_name_assignment.

5.2.4.173 restrict_name_assignment_for_kinematic_structure

The restrict_name_assignment_for_kinematic_structure rule specifies that each instance of kinematic_structure shall be referenced by at most one instance of applied_name_assignment.
*)
RULE restrict_name_assignment_for_kinematic_structure FOR
    (kinematic_structure);
WHERE
  WR1:  SIZEOF(QUERY(ent <* kinematic_structure |
          SIZEOF( USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_NAME_ASSIGNMENT.ITEMS')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

kinematic_structure: the set of all instances of kinematic_structure.

Formal propositions

WR1: For each instance of kinematic_structure there shall be only at most one instance of applied_name_assignment.

5.2.4.174 restrict_name_for_known_source

The restrict_name_for_known_source rule ensures that each instance of known_source has a name of 'ISO 13584 library'.
*)
RULE restrict_name_for_known_source FOR
    (known_source);
WHERE
  WR1:  SIZEOF( QUERY( ks <* known_source |
               (ks.name <> 'ISO 13584 library')
              )) = 0;
           
END_RULE;
(*

Argument definitions:

known_source: the set of all instances of known_source.

Formal propositions

WR1: Each instance of known_source shall have a name of 'ISO 13584 library'.

5.2.4.175 restrict_part_occurrence

The restrict_part_occurrence rule specifies the restrictions that apply to product_definitions which reference as frame_of_reference a product_definition_context with a name of 'part occurrence'.
*)
RULE restrict_part_occurrence FOR
    (product_definition,
     product_definition_occurrence_relationship);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (NOT( pd.name IN ['single instance','selected instance',
                                 'quantified instance','specified instance']))
              )) = 0;
           
  WR2:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION') |
                  pdr.name = 'definition usage' 
                 )) <> 1 ) AND
               (SIZEOF( QUERY( cd <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'CONFIGURATION_DESIGN.DESIGN') |
                  (cd.name = 'occurrence usage definition') AND
                  (NOT('AUTOMOTIVE_DESIGN.PRODUCT_IDENTIFICATION' IN
                       TYPEOF(cd.configuration))) 
                 )) <> 1 )
              )) = 0;      
  WR3:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (SIZEOF( QUERY( cd <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION') |
                  ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_USAGE' IN
                   TYPEOF(cd))
                 )) = 0) AND
               (SIZEOF( USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE')
                 ) = 0)
              )) = 0;
           
  WR4:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (pd.name = 'selected instance') AND
               (SIZEOF( QUERY (prd <* USEDIN(pd,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION') |
                  (prd.name = 'occurrence selection') AND
                  (SIZEOF( QUERY (pdr <* USEDIN(prd,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                     (pdr.used_representation.name = 'selection criteria') AND
                     (SIZEOF(pdr.used_representation.items) = 2) AND
                     (SIZEOF( QUERY( i <* pdr.used_representation.items |
                        (SIZEOF(['AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                                 'AUTOMOTIVE_DESIGN.VALUE_RANGE'] *
                                 TYPEOF(i))
                          = 1) AND
                        (i.name = 'selection quantity')
                       )) = 1) AND
                     (SIZEOF( QUERY( i <* pdr.used_representation.items |
                        ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                         TYPEOF(i)) AND
                        (i.name = 'selection control')
                       )) = 1)
                    )) = 1)
                 )) = 0)
              )) = 0;
              
  WR5:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (pd.name = 'quantified instance') AND
               (SIZEOF( QUERY(ppd <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PROPERTY_DEFINITION.DEFINITION') |
                  (ppd.name = 'occurrence quantity') AND
                  (SIZEOF( QUERY( pdr <* USEDIN(ppd,'AUTOMOTIVE_DESIGN.' +
                           'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                     (pdr.used_representation.name = 'quantity' ) AND
                     (SIZEOF(pdr.used_representation.items) = 1) AND
                     (SIZEOF( QUERY( i <* pdr.used_representation.items |
                        ('AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM' IN
                         TYPEOF(i)) AND
                        (i.name = 'quantity measure')
                       )) = 1) 
                    )) = 1)
                 )) = 0) 
              )) = 0; 
           
  WR6:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'part occurrence') AND
               (pd.name = 'specified instance') AND
               (SIZEOF( QUERY( pdor <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE') |
                  'AUTOMOTIVE_DESIGN.SPECIFIED_HIGHER_USAGE_OCCURRENCE' IN
                  TYPEOF(pdor.occurrence_usage)
                 )) = 0)
              )) = 0;
              
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

product_definition_occurrence_relationship: the set of all instances of product_definition_occurrence_relationship.

product_definition_occurrence_relationship: the set of all instances of product_definition_occurrence_relationship.

Formal propositions

WR1: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence', shall either have a name of 'single instance', 'selected instance', 'quantified instance', or 'specified instance'.

WR2: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence' shall either participate as the related_product_definition in exactly one product_definition_relationship with a name of 'definition usage', or shall be referenced as design by exactly one configuration_design which has a name of 'occurrence usage definition' and which references as configuration a product_identification.

WR3: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence' shall (at least) participate in a product_definition_usage relationship as the related_product_definition or in a product_definition_occurrence_relationship as occurrence.

WR4: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence' and which has a name of 'selected instance', shall be referenced by a property_definition which has a name of 'occurrence selection', and which is referenced as definition by a property_definition_representation which has as used_representation a representation which has a name of 'selection criteria' and which contains exactly two representation_items in its set of items. One of these representation_items shall be of type measure_representation_item or value_range and shall have a name of 'selection quantity'. The other one of these representation_items shall be of type descriptive_representation_item and shall have a name of 'selection control'.

WR5: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence' and which has a name of 'quantified instance', shall be referenced by a property_definition which has a name of 'occurrence quantity', and which is referenced as definition by a property_definition_representation which has as used_representation a representation which has a name of 'quantity' and which contains exactly one representation_item in its set of items. This representation_item is of type measure_representation_item and has a name of 'quantity measure'.

WR6: Each instance of product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence' and which has a name of 'specified instance', shall be referenced as occurrence by a product_definition_occurrence_relationship which references as occurrence_usage a specified_higher_usage_occurrence .

5.2.4.176 restrict_process_product_association

The restrict_process_product_association rule specifies that the only names of process_product_association permitted shall be 'input', 'output', or 'produced output'. Each instance of process_product_association with a name of 'input' or 'output' shall refer to an action that plays the role of related_action for an action_relationship that has a name of 'process operation occurrence'. See definition of Process_operation_input_or_output in paragraph 4.2.383 for more information. Each instance of process_product_association with a name of 'produced output' shall refer to a product_definition that refers as formation to a product_definition_formation that is the formation of a product that is either a part, tool, or raw material. See definition for Process_plan and for Item_version for more information.
*)
RULE restrict_process_product_association FOR
    (process_product_association);
WHERE
  WR1:  SIZEOF( QUERY( ppa <* process_product_association |
               NOT (ppa.name IN ['input','output','produced output'])
              )) = 0;   
  WR2:  SIZEOF( QUERY( ppa <* process_product_association |
               NOT (ppa.name IN ['input','output']) OR
               (SIZEOF( QUERY( ar <* USEDIN(ppa.process,'AUTOMOTIVE_DESIGN.' +
                        'ACTION_RELATIONSHIP.RELATED_ACTION') |
                  ar.name = 'process operation occurrence'
                 )) = 0)
              )) = 0;
           
  WR3:  SIZEOF( QUERY( ppa <* process_product_association |
               (ppa.name <> 'produced output') OR
               (('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION' IN
                 TYPEOF(ppa.defined_product)) AND
                (SIZEOF( QUERY( prpc <* USEDIN(ppa.defined_product\product_definition.formation.of_product,
                         'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                   prpc.name IN ['part','tool','raw material']
                  )) = 0))
              )) = 0;   
END_RULE;
(*

Argument definitions:

process_product_association: the set of all instances of process_product_association.

Formal propositions

WR1: For each instance of process_product_association, the value of the name attribute shall be either 'input', 'output', or 'produced output'.

WR2: If an instance of process_product_association has a name of 'input' or 'output', it shall refer as process to a product_definition_process that is refered as related_action by an action_relationship that has a name of 'process operation occurrence'.

WR3: If an instance of process_product_association has a name of 'produced output', it shall refer to a product_definition that refers as formation to a product_definition_formation that refers as of_product to a product that is contained in the set of products of a product_related_product_category with a name of either 'part', 'tool', or 'raw material'.

5.2.4.177 restrict_product_categories_for_tool_part_relationship

For each instance of product_definition_relationship that has a name of 'tool part relationship', the product_definition used as the relating_product_definition shall be associated to a product_definition_formation referencing a product that is referenced by a product_related_product_category with a name of 'tool', the product_definition used as the related_product_definition shall be associated to a product_definition_formation referencing a product that is referenced by a product_related_product_category with a name of 'part'. This rule enforces the requirement that an Item_definition_relationship that is a Tool_part_relationship relates an item that is used to create a part to a part.
*)
RULE restrict_product_categories_for_tool_part_relationship FOR
    (product_definition_relationship);
WHERE
  WR1:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'tool part relationship') AND
               ((SIZEOF( QUERY( prpc <* USEDIN(pdr.relating_product_definition.formation.of_product,
        		'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                   prpc.name = 'tool'
        	  )) < 1) OR
        	(SIZEOF( QUERY( prpc <* USEDIN(pdr.related_product_definition.formation.of_product,
                         'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                   prpc.name = 'part'
        	  )) < 1)) 
              )) = 0;  
           
END_RULE;
(*

Argument definitions:

product_definition_relationship: the set of all instances of product_definition_relationship.

Formal propositions

WR1: For each instance of product_definition_relationship that has a name of 'tool part relationship', the product_definition used as the relating_product_definition shall be associated to a product_definition_formation referencing a product that is referenced by a product_related_product_category with a name of 'tool', the product_definition used as the related_product_definition shall be associated to a product_definition_formation referencing a product that is referenced by a product_related_product_category with a name of 'part'.

5.2.4.178 restrict_product_category_for_product

The restrict_product_category_for_product rule enforces the existence of a product_related_product_category with a name of either 'part', 'raw material', 'tool', 'document', 'functionality', 'conceptual product, 'alternative solution', 'requirement', or 'physically realized product' for each product.
*)
RULE restrict_product_category_for_product FOR
    (product);
WHERE
  WR1:  SIZEOF(QUERY(p <* product |
               SIZEOF(QUERY(prpc <* USEDIN(p,'AUTOMOTIVE_DESIGN.' +
                      'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                 prpc.name IN ['part','raw material','tool','document','functionality',
                               'conceptual product','alternative solution','requirement',
                               'physically realized product'] )
                ) = 0 
              )) = 0;
           
  WR2:  SIZEOF(QUERY(p <* product |
               SIZEOF(QUERY(prpc <* USEDIN(p,'AUTOMOTIVE_DESIGN.' +
                      'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                 prpc.name IN ['part','document','functionality',
                               'conceptual product','alternative solution','requirement',
                               'physically realized product','tool','raw material'] )
                ) > 1 
              )) = 0;
        
              
END_RULE;
(*

Argument definitions:

product: the set of all instances of product.

Formal propositions

WR1: Each instance of product shall be referenced by a product_related_product_category with a name of either 'part', 'raw material', 'tool', 'document', 'functionality', 'conceptual product', 'alternative solution', 'requirement', or 'physically realized product'.

WR2: Each instance of product shall be referenced by at most one product_related_product_category with a name of 'part', 'raw material', 'tool',  'document', 'functionality', 'conceptual product', 'alternative solution', 'requirement', or 'physically realized product'.

5.2.4.179 restrict_product_definition_context_for_external_properties

The restrict_product_definition_context_for_external_properties rule specifies that a product_definition which is referenced as the definition by a property_definition which itself is referenced as the derived_definition by a general_property_association that references as the base_definition an externally_defined_general_property, shall be referenced as the definition by a product_definition_context_association which has as the frame_of_reference a product_definition_context with a name of 'external' and which references as its role a product_definition_context_role with a name of 'external'.
*)
RULE restrict_product_definition_context_for_external_properties FOR
    (general_property_association,
     product_definition);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (SIZEOF( 
        
            QUERY ( propd <* USEDIN (pd, 'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION') |
                  (SIZEOF 
                         (QUERY( gpa <* USEDIN(propd,'AUTOMOTIVE_DESIGN.' +
                        'GENERAL_PROPERTY_ASSOCIATION.DERIVED_DEFINITION') |
                        'AUTOMOTIVE_DESIGN.' + 'EXTERNALLY_DEFINED_GENERAL_PROPERTY'
                        IN TYPEOF (gpa.base_definition) 
)) > 0))) > 0) 
               AND
                        (SIZEOF
                         (QUERY( pdca <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                           'PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                         (pdca.frame_of_reference.name = 'external') 
                           AND
                         (pdca.role.name = 'external'))) = 0 ))) = 0;
           
END_RULE;
(*

Argument definitions:

general_property_association: the set of all instances of general_property_association.

product_definition: the set of all instances of product_definition.

product_definition: the set of all instances of product_definition.

Formal propositions

WR1: Each instance of product_definition which is referenced as the definition by a property_definition which itself is referenced as the derived_definition by a general_property_association that references as the base_definition an externally_defined_general_property, shall be referenced as the definition by a product_definition_context_association which has as the frame_of_reference a product_definition_context with a name of 'external' and which references as its role a product_definition_context_role with a name of 'external'.

5.2.4.180 restrict_product_definition_context_for_product

The restrict_product_definition_context_for_product rule ensures the correct correlation between the name of the product_definition_context which is referenced as the frame_of_reference by a product_definition and the product_related_product_category of the associated product.
*)
RULE restrict_product_definition_context_for_product FOR
    (product_definition,
     product_related_product_category);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name IN ['part definition','part occurrence']) AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,
                        'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name IN ['part','raw material','tool']
                 )) = 0 )
              )) = 0;
           
  WR2:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'functional definition') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,
                        'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'functionality'
                 )) = 0 )
              )) = 0;      
  WR3:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'conceptual definition') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,
                        'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'conceptual product'
                 )) = 0 )
              )) = 0;      
  WR4:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'alternative definition') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,
                        'AUTOMOTIVE_DESIGN.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'alternative solution'
                 )) = 0 )
              )) = 0;   
  WR5:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'design constraint definition') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'requirement'
                 )) = 0 )
              )) = 0;
              
  WR6:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'physical occurrence') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'physically realized product'
                 )) = 0 )
              )) = 0;   
  WR7:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name = 'physical document definition') AND
               (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') |
                  prpc.name = 'document'
                 )) = 0 )
              )) = 0;   
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

product_related_product_category: the set of all instances of product_related_product_category.

product_related_product_category: the set of all instances of product_related_product_category.

Formal propositions

WR1: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'part definition' or 'part occurrence', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'part', 'raw material', or 'tool'.

WR2: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'functional definition', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'functionality'.

WR3: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'conceptual definition', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'conceptual product'.

WR4: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'alternative definition', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'alternative solution'.

WR5: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'design constraint definition', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'requirement'.

WR6: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'physical occurrence', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'physically realized product'.

WR7: If the product_definition references as its frame_of_reference a product_definition_context with a name of 'physical document definition', 'digital document definition', or 'physical model occurrence', this product_definition shall reference as its formation a product_definition_formation which references as of_product a product which is in the set of products of a product_related_product_category with a name of 'document'.

5.2.4.181 restrict_product_definition_for_mating_tree

The restrict_product_definition_for_mating_tree rule specifies that each instance of product_definition with a product_definition_context that has a name of 'mating definition' associated by a product_definition_context_association shall be referenced by exactly two instances of product_definition_relationship as the relating_product_definition. These two instances of product_definition_relationship shall have a name of 'mating membership'. Either both or one shall reference as related_product_definition each an instance of product_definition with a product_definition_context that has a name of 'part occurrence'. In the later case, the other instance of product_definition shall have a product_definition_context with a name of 'mating definition' specified through a product_definition_context_association. This rule ensures that the Mated_item_association is transformed in a binary mating tree. The bottommost node of such a mating tree is a Mating_definition that consists of two Item_instances. Every other node of Mating_definition is created by its subnode and an additional Item_instance that is added to the already mated instances. See definition of Mating_definition in paragraph 4.2.313 and for Mated_item_association in paragraph 4.2.307 for more information.
*)
RULE restrict_product_definition_for_mating_tree FOR
    (product_definition);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (SIZEOF( QUERY( pdca <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                  pdca.frame_of_reference.name = 'mating definition'
                 )) = 1 ) AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
                  pdr.name = 'mating membership'
                 )) <> 2 )
              )) = 0;
           
  WR2:  SIZEOF( QUERY( pd <* product_definition |
               (SIZEOF( QUERY( pdca <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                  pdca.frame_of_reference.name = 'mating definition'
                 )) = 1 ) AND
               NOT({ 1 <= SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                                  'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
                            (pdr.name = 'mating membership') AND
                            (pdr.related_product_definition.frame_of_reference.name = 'part occurrence')
                           )) <= 2 })
             )) = 0;   
  WR3:  SIZEOF( QUERY( pd <* product_definition |
               (SIZEOF( QUERY( pdca <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                  pdca.frame_of_reference.name = 'mating definition'
                 )) = 1 ) AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                    'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
                  (pdr.name = 'mating membership') AND
                  (SIZEOF( QUERY( pdca <* USEDIN(pdr.related_product_definition,
                           'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                     pdca.frame_of_reference.name = 'mating definition'
                    )) = 1 )
                 )) > 1 )
              )) = 0;
           
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

Formal propositions

WR1: Each instance of product_definition that has a product_definition_context with name of 'mating definition' specified through a product_definition_context_association shall be referenced as the relating_product_definition by exactly two product_definition_relationships with a name of 'mating membership'.

WR2: Each instance of product_definition with a product_definition_context that has a name of 'mating definition' specified through a product_definition_context_association shall be referenced as the relating_product_definition by either one or two instances of product_definition_relationship that have a name of 'mating membership' and that reference as related_product_definition an instance of product_definition with a product_definition_context that has a name of 'part occurrence'.

WR3: Each instance of product_definition with a product_definition_context that has a name of 'mating definition' specified through a product_definition_context_association shall be referenced as the relating_product_definition by at most one instance of product_definition_relationship that has a name of 'mating membership' and that references as related_product_definition an instance of product_definition with a product_definition_context that has a name of 'mating definition' specified through a product_definition_context_association.

5.2.4.182 restrict_product_definition_substitute

The restrict_product_definition_substitute rule specifies the restrictions that apply to the usage of product_definition_substitute .
*)
RULE restrict_product_definition_substitute FOR
    (product_definition_substitute);
WHERE
  WR1:  SIZEOF( QUERY( pds <* product_definition_substitute |
               (SIZEOF( USEDIN(pds,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_EFFECTIVITY_ASSIGNMENT.ITEMS') 
                 ) = 0 )
              )) = 0;
              
  WR2:  SIZEOF( QUERY( pds <* product_definition_substitute |
               pds.substitute_definition.frame_of_reference.name <> 'part occurrence'
              )) = 0;
              
  WR3:  SIZEOF( QUERY( pds <* product_definition_substitute |
               (('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN
                 TYPEOF(pds.context_relationship)) AND
                (SIZEOF( USEDIN(pds.context_relationship,'AUTOMOTIVE_DESIGN.' +
                         'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE_USAGE')
                   ) = 0)) AND
               (('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_RELATIONSHIP' IN
                 TYPEOF(pds.context_relationship)) AND
                (pds.context_relationship.related_product_definition.frame_of_reference.name <>
                 'part occurrence'))
              )) = 0;
           
END_RULE;
(*

Argument definitions:

product_definition_substitute: the set of all instances of product_definition_substitute.

Formal propositions

WR1: For each instance of product_definition_substitute there shall be at least one instance of applied_effectivity_assignment that contains the instance in its set of items. This rule enforces the requirement for every instance of Replaced_usage_relationship to have at least one Effectivity applied to it specifiying the start of the validity of the replacement.

WR2: Each instance of product_definition_substitute shall reference as substitute_definition a product_definition which references as frame_of_reference a product_definition_context with a name of 'part occurrence'.

WR3: Each instance of product_definition_substitute shall reference as context_relationship an assembly_component_usage which is referenced as occurrence_usage by a product_definition_occurrence_relationship, or shall reference as context_relationship a product_definition_relationship with a related_product_definition which references as its frame_of_reference a product_definition_context with a name of 'part occurrence'.

5.2.4.183 restrict_product_definitions_for_product_definition_relationship

The restrict_product_definitions_for_product_definition_relationship rule ensures the correct correlation between the name or type of the product_definition_relationship and the product_definition_context of the related product_definitions.
*)
RULE restrict_product_definitions_for_product_definition_relationship FOR
    (assembly_component_usage,
     product_definition_relationship);
WHERE
  WR1:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'definition usage') AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'part definition') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'part occurrence'))
              )) = 0;
           
  WR2:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name IN ['geometrical relationship','definition replacement']) AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'part definition') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'part definition'))
              )) = 0;
           
  WR3:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               ('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN
                TYPEOF(pdr)) AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'part definition') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'part definition')) AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'physical occurrence') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'physical occurrence'))
              )) = 0;
           
  WR4:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               ('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN
                TYPEOF(pdr)) AND
               (pdr.name = 'selected instance usage') AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'part definition') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'part definition'))
              )) = 0;
           
  WR5:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'physical realization') AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'part 
 definition') OR
                (pdr.related_product_definition.frame_of_reference.name <> 'physical occurrence'))
              )) = 0;
           
  WR6:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'physical occurrence usage') AND
               (NOT('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN
                    TYPEOF(pdr)) OR
               (pdr.relating_product_definition.frame_of_reference.name <> 'physical occurrence') OR
               (pdr.related_product_definition.frame_of_reference.name <> 'physical occurrence'))
              )) = 0;      
  WR7:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'solution alternative definition') AND
               (NOT(pdr.relating_product_definition.frame_of_reference.name IN
                    ['alternative definition','functional definition','conceptual definition']) OR
               (pdr.related_product_definition.frame_of_reference.name <>'alternative definition'))
              )) = 0;      
  WR8:   SIZEOF( QUERY( pdr <* product_definition_relationship |
                (pdr.name = 'collection membership') AND
                ((pdr.relating_product_definition.frame_of_reference.name <> 'part definition') OR
                 (pdr.related_product_definition.frame_of_reference.name <> 'part occurrence') OR
                 (SIZEOF( QUERY( pdca <* USEDIN(pdr.relating_product_definition,
                          'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
                    (pdca.role.name = 'part definition type') AND
                    (pdca.frame_of_reference.name = 'collection definition')
                   )) = 0 ))
               )) = 0;
              
  WR9:  SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'design constraint association') AND
               ((pdr.relating_product_definition.frame_of_reference.name <> 'design constraint definition') OR
               NOT(pdr.related_product_definition.frame_of_reference.name IN
                   ['alternative definition','functional definition','conceptual definition']))
              )) = 0;      
  WR10: SIZEOF( QUERY( pdr <* product_definition_relationship |
               (pdr.name = 'final specification') AND
               (NOT(pdr.relating_product_definition.name IN
                    ['final','technical final','supplier final',
                     'technical supplier final']) OR
               (pdr.relating_product_definition.frame_of_reference.name <> 'alternative definition')
 OR
               NOT(pdr.related_product_definition.frame_of_reference.name IN
                   ['part definition','physical occurrence']))
              )) = 0;      
END_RULE;
(*

Argument definitions:

assembly_component_usage: the set of all instances of assembly_component_usage.

product_definition_relationship: the set of all instances of product_definition_relationship.

product_definition_relationship: the set of all instances of product_definition_relationship.

Formal propositions

WR1: If the product_definition_relationship has a name of 'definition usage', the relating_product_definition shall reference as its frame_of_reference a product_definition_context with a name of 'part definition', and the related_product_definition shall reference as its frame_of_reference a product_definition_context with a name of 'part occurrence'.

WR2: If the product_definition_relationship has a name of 'geometrical relationship' or 'definition replacement', the relating_product_definition and the related_product_definition shall reference as its frame_of_reference a product_definition_context with a name of 'part definition'.

WR3: If the product_definition_relationship is of type assembly_component_usage, the relating_product_definition and the related_product_definition shall either both reference as their frame_of_reference a product_definition_context with a name of 'part definition', or shall both reference as their frame_of_reference a product_definition_context with a name of 'physical occurrence'.

WR4: If the product_definition_relationship is of type assembly_component_usage and has a name of 'selected instance usage', the relating_product_definition and the related_product_definition shall both reference as their frame_of_reference a product_definition_context with a name of 'part definition'.

WR5: If the product_definition_relationship has a name of 'physical realization', the relating_product_definition shall reference as its frame_of_reference a product_definition_context with a name of 'part definition', and the related_product_definition shall reference as its frame_of_reference a product_definition_context with a name of 'physical occurrence'.

WR6: If the product_definition_relationship has a name of 'physical occurrence usage', it shall be of type assembly_component_usage and both the relating_product_definition and the related_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'physical occurrence' .

WR7: If the product_definition_relationship has a name of 'solution alternative definition', the relating_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'alternative definition', 'functional definition' or 'conceptual definition', and the related_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'alternative definition'.

WR8: If the product_definition_relationship has a name of 'collection membership', the related_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'part occurrence', and the relating_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'part definition' and shall be referenced as the definition by a product_definition_context_association. This product_definition_context_association shall reference as its role a product_definition_context_role with a name of 'part definition type' and shall reference as its frame_of_reference a product_definition_context with a name of 'collection definition'.

WR9: If the product_definition_relationship has a name of 'design constraint association', the relating_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'design constraint definition', and the related_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'alternative definition', 'functional definition', or 'conceptual definition'.

WR10: If the product_definition_relationship has a name of 'final specification', the relating_product_definition shall have a name of 'final', 'technical final', 'supplier final', or 'technical supplier final' and shall reference as frame_of_reference a product_definition_context with a name of 'alternative definition', and the related_product_definition shall reference as frame_of_reference a product_definition_context with a name of 'part definition', or 'physical occurrence'.

5.2.4.184 restrict_properties_of_document_file

The restrict_properties_of_document_file rule specifies the restrictions that apply for properties of digital_files.
*)
RULE restrict_properties_of_document_file FOR
    (document_file);
WHERE
  WR1:  SIZEOF( QUERY( df <* document_file |
               SIZEOF( QUERY( pd <* USEDIN(df,'AUTOMOTIVE_DESIGN.' +
                        'PROPERTY_DEFINITION.DEFINITION') |
                 pd.name = 'document property'
                 )) > 1
              )) = 0;
           
  WR2:  SIZEOF( QUERY( df <* document_file |
               SIZEOF( QUERY( rt <* df.representation_types |
                 ('AUTOMOTIVE_DESIGN.DOCUMENT_REPRESENTATION_TYPE' IN
                  TYPEOF(rt)) AND
                 (rt.name IN ['digital','physical'])
                 )) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

document_file: the set of all instances of document_file.

Formal propositions

WR1: Each instance of document_file shall be referenced as definition by at most one property_definition with a name of 'document property'.

WR2: Each instance of document_file shall reference as representation_types an instance of document_representation_type with a name of either 'digital', or 'physical'.

5.2.4.185 restrict_properties_of_document_representation

The restrict_properties_of_document_representation rule specifies the restrictions that apply for properties of document_representations.
*)
RULE restrict_properties_of_document_representation FOR
    (product_definition);
WHERE
  WR1:  SIZEOF( QUERY( pd <* product_definition |
               (pd.frame_of_reference.name IN ['physical document definition',
                'digital document definition','physical model occurrence']) AND
               (SIZEOF( QUERY( pd1 <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                        'PROPERTY_DEFINITION.DEFINITION') |
                  pd1.name = 'document property'
                 )) > 1)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

product_definition: the set of all instances of product_definition.

Formal propositions

WR1: Each instance of product_definition that references as frame_of_reference a application_context_element with a name of either 'physical document definition', 'digital document definition', or 'physical model occurrence' shall be referenced as definition by at most one property_definition with a name of 'document property'.

5.2.4.186 restrict_representation_for_document_content_property

The restrict_representation_for_document_content_property rule specifies the restrictions that apply for representations with a name of 'document content'.
*)
RULE restrict_representation_for_document_content_property FOR
    (representation,
     representation_item);
WHERE
  WR1:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document content') AND
               ((SIZEOF(r.items) < 1) OR
                (SIZEOF(r.items) > 3))
              )) = 0;   
  WR2:  SIZEOF( QUERY( ri <* representation_item |
               (SIZEOF( QUERY( r <* USEDIN(ri,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                  r.name = 'document content'
                 )) > 0) AND
               NOT(ri.name IN ['detail level','geometry type','real world scale'])
              )) = 0;   
  WR3:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document content') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'detail level') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
           
  WR4:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document content') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'geometry type') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;   
  WR5:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document content') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'real world scale') AND
                  (SIZEOF(['AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                           'AUTOMOTIVE_DESIGN.VALUE_REPRESENTATION_ITEM'] *
                           TYPEOF(i)
                    ) = 1)
                 )) > 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

representation_item: the set of all instances of representation_item.

representation_item: the set of all instances of representation_item.

Formal propositions

WR1: For each instance of representation which has a name of 'document content' there shall be at least one and at most three instances of representation_items in the set of items.

WR2: Each instance of representation_item that is referenced as items by an instance of representation with a name of 'document content' shall have a name of either 'detail level', 'geometry type', or 'real world scale'.

WR3: There shall be at most one instance of representation_item that have a name of 'detail level' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document content'.

WR4: There shall be at most one instance of representation_item that have a name of 'geometry type' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document content'.

WR5: There shall be at most one instance of representation_item that have a name of 'real world scale' and which is either of type measure_representation_item, or value_representation_item that is referenced as items by an instance of representation with a name of 'document content'.

5.2.4.187 restrict_representation_for_document_creation_property

The restrict_representation_for_document_creation_property rule specifies the restrictions that apply for representations with a name of 'document creation'.
*)
RULE restrict_representation_for_document_creation_property FOR
    (representation,
     representation_item);
WHERE
  WR1:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document creation') AND
               ((SIZEOF(r.items) < 
 1) OR
                (SIZEOF(r.items) > 3))
              )) = 0;   
  WR2:  SIZEOF( QUERY( ri <* representation_item |
               (SIZEOF( QUERY( r <* USEDIN(ri,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                  r.name = 'document creation'
                 )) > 0) AND
               NOT(ri.name IN ['creating interface','creating system','operating system'])
              )) = 0;
           
  WR3:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document creation') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'creating interface') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
           
  WR4:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document creation') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'creating system') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) <> 1)
              )) = 0;
           
  WR5:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document creation') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'operating system') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

representation_item: the set of all instances of representation_item.

representation_item: the set of all instances of representation_item.

Formal propositions

WR1: For each instance of representation which has a name of 'document creation' there shall be at least one and at most three instances of representation_items in the set of items.

WR2: Each instance of representation_item that is referenced as items by an instance of representation with a name of 'document creation' shall have a name of either 'creating interface', 'creating system', or 'operating system'.

WR3: There shall be at most one instance of representation_item that have a name of 'creating interface' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document creation'.

WR4: There shall be exactly one instance of representation_item that have a name of 'creating system' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document creation'.

WR5: There shall be at most one instance of representation_item that have a name of 'operating system' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document creation'.

5.2.4.188 restrict_representation_for_document_format_property

The restrict_representation_for_document_format_property rule specifies the restrictions that apply for representations with a name of 'document format'.
*)
RULE restrict_representation_for_document_format_property FOR
    (representation,
     representation_item);
WHERE
  WR1:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document format') AND
               ((SIZEOF(r.items) < 1) OR
                (SIZEOF(r.items) > 3 
))
              )) = 0;
           
  WR2:  SIZEOF( QUERY( ri <* representation_item |
               (SIZEOF( QUERY( r <* USEDIN(ri,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                  r.name = 'document format'
                 )) > 0) AND
               NOT(ri.name IN ['character code','data format','size format'])
              )) = 0;
           
  WR3:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document format') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'character code') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
           
  WR4:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document format') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'data format') AND
                  ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
              
    WR5:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document format') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'size format') AND
                  ('AUTOMOTIVE_DESIGN.PLANAR_EXTENT' IN
                   TYPEOF(i))
                 )) > 1)
              )) = 0;
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

representation_item: the set of all instances of representation_item.

Formal propositions

WR1: For each instance of representation which has a name of 'document format' there shall be at least one and at most three instances of representation_items in the set of items.

WR2: Each instance of representation_item that is referenced as items by an instance of representation with a name of 'document format' shall have a name of either 'character code', 'data format', or 'size format'.

WR3: There shall be at most one instance of representation_item that has a name of 'character code' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document format'.

WR4: There shall be at most one instance of representation_item that has a name of 'data format' and which is of type descriptive_representation_item that is referenced as items by an instance of representation with a name of 'document format'.

WR5: There shall be at most one instance of representation_item that has a name of 'size format' and which is of type planar_extent that is referenced as items by an instance of representation with a name of 'document format'.

5.2.4.189 restrict_representation_for_document_properties

The restrict_representation_for_document_properties rule specifies that each instance of property_definition with a name of 'document property' shall be represented by representations with a name of either 'document content', 'document creation', 'document format', or 'document size'. At the same time, this rules enforces that each instance of representation with a name of either 'document content', 'document creation', 'document format', or 'document size', shall be referenced by one instance of property_definition with a name of 'document property'.
*)
RULE restrict_representation_for_document_properties FOR
    (property_definition,
     representation,
     representation_context);
WHERE
  WR1:  SIZEOF( QUERY( pd <* property_definition |
               (pd.name = 'document property' ) AND
               (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.'+
                        'PROPERTY_DEFINITION_REPRESENTATION.' +
                        'DEFINITION') |
                  NOT(pdr.used_representation.name IN 
                      ['document content','document creation','document format','document size'])
                 )) > 0)
              )) = 0;
           
  WR2:  SIZEOF( QUERY( r <* representation |
               (r.name IN ['document content','document creation','document format','document size'] ) AND
               (SIZEOF( QUERY( pdr <* USEDIN(r,'AUTOMOTIVE_DESIGN.'+
                         'PROPERTY_DEFINITION_REPRESENTATION.' +
                        'USED_REPRESENTATION') |
                  ('AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION' IN
                   TYPEOF(pdr.definition)) AND
                  (pdr.definition.name = 'document property')
                 )) = 0)
              )) = 0;
           
  WR3:  SIZEOF( QUERY( r <* representation |
               (r.name IN ['document content','document creation','document format','document size'] ) AND
               (r.context_of_items.context_type <> 'document parameters')
              )) = 0;
           
  WR4:  SIZEOF( QUERY( rc <* representation_context |
               (rc.context_type = 'document parameters') AND
               (SIZEOF( QUERY( r <* USEDIN(rc,'AUTOMOTIVE_DESIGN.REPRESENTATION.CONTEXT_OF_ITEMS') |
                  NOT(r.name IN ['document content','document creation','document format','document size'])
                 )) > 0)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

property_definition: the set of all instances of property_definition.

representation: the set of all instances of representation.

representation_context: the set of all instances of representation_context.

representation: the set of all instances of representation.

representation_context: the set of all instances of representation_context.

Formal propositions

WR1: Each instance of property_definition with a name of 'document property' shall be referenced as definition by a property_definition_representation, which has as used_representation a representation with a name of either 'document content', 'document creation', 'document format', or 'document size'.

WR2: Each instance of representation with a name of either 'document content', 'document creation', 'document format', or 'document size' shall be referenced as used_representation by a property_definition_representation, which has as definition a property_definition with a name of 'document property'.

WR3: Each instance of representation with a name of either 'document content', 'document creation', 'document format', or 'document size' shall reference as context_of_items a representation_context, with a context_type of 'document parameters'.

WR4: Each instance of representation_context with a context_type of 'document parameters' shall be referenced as context_of_items by a representation with a name of either 'document content', 'document creation', 'document format', or 'document size'.

5.2.4.190 restrict_representation_for_document_size_property

The restrict_representation_for_document_size_property rule specifies the restrictions that apply for representations with a name of 'document size'.
*)
RULE restrict_representation_for_document_size_property FOR
    (representation,
     representation_item);
WHERE
  WR1:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document size') AND
               ((SIZEOF(r.items) < 1) OR
                (SIZEOF(r.items) > 2))
              )) = 0;
           
  WR2:  SIZEOF( QUERY( ri <* representation_item |
               (SIZEOF( QUERY( r <* USEDIN(ri,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') |
                  r.name = 'document size'
                 )) > 0) AND
               NOT(ri.name IN ['file size','page count'])
              )) = 0;
           
  WR3:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document size') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'file size') AND
                  (SIZEOF(['AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                           'AUTOMOTIVE_DESIGN.VALUE_RANGE',
                           'AUTOMOTIVE_DESIGN.VALUE_REPRESENTATION_ITEM'] *
                           TYPEOF(i)
                    ) = 1)
                 )) > 1)
              )) = 0;
           
  WR4:  SIZEOF( QUERY( r <* representation |
               (r.name = 'document size') AND
               (SIZEOF( QUERY( i <* r.items |
                  (i.name = 'page count') AND
                  (SIZEOF(['AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                           'AUTOMOTIVE_DESIGN.VALUE_RANGE',
                           'AUTOMOTIVE_DESIGN.VALUE_REPRESENTATION_ITEM'] *
                           TYPEOF(i)
                    ) = 1)
                 )) > 1)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

representation_item: the set of all instances of representation_item.

representation_item: the set of all instances of representation_item.

Formal propositions

WR1: For each instance of representation which has a name of 'document size' there shall be at least one and at most two instances of representation_items in the set of items.

WR2: Each instance of representation_item that is referenced as items by an instance of representation with a name of 'document size' shall have a name of either 'file size', or 'page count'.

WR3: There shall be at most one instance of representation_item that have a name of 'file size' and which is either of type measure_representation_item, value_range, or value_representation_item that is referenced as items by an instance of representation with a name of 'document size'.

WR4: There shall be at most one instance of representation_item that have a name of 'page count' and which is either of type measure_representation_item, value_range, or value_representation_item that is referenced as items by an instance of representation with a name of 'document size'.

5.2.4.191 restrict_representation_item_for_hybrid_geometric_model_3d

The restrict_representation_item_for_hybrid_geometric_model_3d specifies that each instance of shape_representation with a name of 'hybrid 3d shape representation' shall have only geometric_representation_items in its set of items.
*)
RULE restrict_representation_item_for_hybrid_geometric_model_3d FOR
    (shape_representation);
WHERE
  WR1:  SIZEOF( QUERY( sr <* shape_representation |
               (sr.name = 'hybrid 3d shape representation') AND
               (SIZEOF( QUERY( i <* sr.items |
                  NOT ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' IN
                       TYPEOF(i))
                 )) > 0)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

shape_representation: the set of all instances of shape_representation.

Formal propositions

WR1: Each instance of shape_representation with a name of 'hybrid 3d shape representation' shall have only geometric_representation_items in its set of items.

5.2.4.192 restrict_treatment_result

The restrict_treatment_result rule ensures the correct usage of an representation that fulfills the requirement of a Treatment_result.
*)
RULE restrict_treatment_result FOR
    (representation);
WHERE
  WR1:  (SIZEOF( QUERY( r <* representation | 
               (r.name = 'treatment result') AND
               (SIZEOF(r.items) > 2)
               )) = 0) AND
             (SIZEOF( QUERY( r <* representation | 
               (r.name = 'treatment result') AND
               (SIZEOF( QUERY( i <* r.items |
                 NOT ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN
                      TYPEOF(i))
                 )) > 0)
               )) = 0);   
  WR2:  SIZEOF( QUERY( r <* representation | 
              (r.name = 'treatment result') AND
              (SIZEOF( QUERY( i <* r.items |
                i.name = 'result'
                )) = 0)
              )) = 0;   
  WR3:  SIZEOF( QUERY( r <* representation | 
              (r.name = 'treatment result') AND
              (SIZEOF( QUERY( i <* r.items |
                i.name = 'purpose'
                )) > 1)
              )) = 0;   
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of representation that has a name of 'treatment result' shall contain at most 2 representation_items in its set of items. These representation_items shall be of type descriptive_representation_item.

WR2: Exactly one representation_item shall have a name of 'result'.

WR3: At most one representation_item shall have a name of 'purpose'.

5.2.4.193 restrict_version_assignment_for_action

The restrict_version_assignment_for_action rule specifies that each instance of action shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the action.
*)
RULE restrict_version_assignment_for_action FOR
    (action);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

action: the set of all instances of action.

Formal propositions

WR1: For each instance of action there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.194 restrict_version_assignment_for_action_directive

The restrict_version_assignment_for_action_directive rule specifies that each instance of action_directive shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the action_directive.
*)
RULE restrict_version_assignment_for_action_directive FOR
    (action_directive);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_directive |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_directive: the set of all instances of action_directive.

Formal propositions

WR1: For each instance of action_directive there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.195 restrict_version_assignment_for_action_method

The restrict_version_assignment_for_action_method rule specifies that each instance of action_method shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the action_method.
*)
RULE restrict_version_assignment_for_action_method FOR
    (action_method);
WHERE
  WR1:  SIZEOF(QUERY(ent <* action_method |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

action_method: the set of all instances of action_method.

Formal propositions

WR1: For each instance of action_method there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.196 restrict_version_assignment_for_applied_identification_assignment

The restrict_version_assignment_for_applied_identification_assignment rule specifies that each instance of applied_identification_assignment shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the applied_identification_assignment.
*)
RULE restrict_version_assignment_for_applied_identification_assignment FOR
    (applied_identification_assignment);
WHERE
  WR1:  SIZEOF(QUERY(ent <* applied_identification_assignment |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

applied_identification_assignment: the set of all instances of applied_identification_assignment.

Formal propositions

WR1: For each instance of applied_identification_assignment there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.197 restrict_version_assignment_for_class

The restrict_version_assignment_for_class rule specifies that each instance of class shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the class.
*)
RULE restrict_version_assignment_for_class FOR
    (class);
WHERE
  WR1:  SIZEOF(QUERY(ent <* class |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

class: the set of all instances of class.

Formal propositions

WR1: For each instance of class there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.198 restrict_version_assignment_for_configuration_item

The restrict_version_assignment_for_configuration_item rule specifies that each instance of configuration_item shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the configuration_item.
*)
RULE restrict_version_assignment_for_configuration_item FOR
    (configuration_item);
WHERE
  WR1:  SIZEOF(QUERY(ent <* configuration_item |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

configuration_item: the set of all instances of configuration_item.

Formal propositions

WR1: For each instance of configuration_item there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.199 restrict_version_assignment_for_document_file

The restrict_version_assignment_for_document_file rule specifies that each instance of document_file shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the document_file.
*)
RULE restrict_version_assignment_for_document_file FOR
    (document_file);
WHERE
  WR1:  SIZEOF(QUERY(ent <* document_file |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

document_file: the set of all instances of document_file.

Formal propositions

WR1: For each instance of document_file there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.200 restrict_version_assignment_for_draughting_model

The restrict_version_assignment_for_draughting_model rule specifies that each instance of draughting_model shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the draughting_model.
*)
RULE restrict_version_assignment_for_draughting_model FOR
    (draughting_model);
WHERE
  WR1:  SIZEOF(QUERY(ent <* draughting_model |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

draughting_model: the set of all instances of draughting_model.

Formal propositions

WR1: For each instance of draughting_model there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.201 restrict_version_assignment_for_effectivity

The restrict_version_assignment_for_effectivity rule specifies that each instance of effectivity shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the effectivity.
*)
RULE restrict_version_assignment_for_effectivity FOR
    (effectivity);
WHERE
  WR1:  SIZEOF(QUERY(ent <* effectivity |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

effectivity: the set of all instances of effectivity.

Formal propositions

WR1: For each instance of effectivity there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.202 restrict_version_assignment_for_general_property

The restrict_version_assignment_for_general_property rule specifies that each instance of general_property shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the general_property.
*)
RULE restrict_version_assignment_for_general_property FOR
    (general_property);
WHERE
  WR1:  SIZEOF(QUERY(ent <* general_property |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

general_property: the set of all instances of general_property.

Formal propositions

WR1: For each instance of general_property there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.203 restrict_version_assignment_for_m_d_g_p_r

The restrict_version_assignment_for_m_d_g_p_r rule specifies that each instance of mechanical_design_geometric_presentation_representation shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the mechanical_design_geometric_presentation_representation.
*)
RULE restrict_version_assignment_for_m_d_g_p_r FOR
    (mechanical_design_geometric_presentation_representation);
WHERE
  WR1:  SIZEOF(QUERY(ent <* mechanical_design_geometric_presentation_representation |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

mechanical_design_geometric_presentation_representation: the set of all instances of mechanical_design_geometric_presentation_representation.

Formal propositions

WR1: For each instance of mechanical_design_geometric_presentation_representation there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.204 restrict_version_assignment_for_presentation_area

The restrict_version_assignment_for_presentation_area rule specifies that each instance of presentation_area shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the presentation_area.
*)
RULE restrict_version_assignment_for_presentation_area FOR
    (presentation_area);
WHERE
  WR1:  SIZEOF(QUERY(ent <* presentation_area |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

presentation_area: the set of all instances of presentation_area.

Formal propositions

WR1: For each instance of presentation_area there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.205 restrict_version_assignment_for_product_concept

The restrict_version_assignment_for_product_concept rule specifies that each instance of product_concept shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the product_concept.
*)
RULE restrict_version_assignment_for_product_concept FOR
    (product_concept);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept: the set of all instances of product_concept.

Formal propositions

WR1: For each instance of product_concept there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.206 restrict_version_assignment_for_product_concept_feature

The restrict_version_assignment_for_product_concept_feature rule specifies that each instance of product_concept_feature shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the product_concept_feature.
*)
RULE restrict_version_assignment_for_product_concept_feature FOR
    (product_concept_feature);
WHERE
  WR1:  SIZEOF(QUERY(ent <* product_concept_feature |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

product_concept_feature: the set of all instances of product_concept_feature.

Formal propositions

WR1: For each instance of product_concept_feature there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.207 restrict_version_assignment_for_shape_representation

The restrict_version_assignment_for_shape_representation rule specifies that each instance of shape_representation shall be referenced by at most one instance of applied_identification_assignment that specifies the version of the shape_representation.
*)
RULE restrict_version_assignment_for_shape_representation FOR
    (shape_representation);
WHERE
  WR1:  SIZEOF(QUERY(ent <* shape_representation |
          SIZEOF(QUERY(ia <* USEDIN(ent,
               'AUTOMOTIVE_DESIGN.' +
               'APPLIED_IDENTIFICATION_ASSIGNMENT.ITEMS') |
               ia.role.name = 'version')) > 1)
              ) = 0;
END_RULE;
(*

Argument definitions:

shape_representation: the set of all instances of shape_representation.

Formal propositions

WR1: For each instance of shape_representation there shall be only at most one instance of applied_identification_assignment with a role name of 'version'.

5.2.4.208 restrict_viewing_plane_usage

The restrict_viewing_plane_usage rule ensures the correct usage of the viewing plane capabilities for tolerances. It constrains the usage to the types of geometric_tolerance that are applicable.
*)
RULE restrict_viewing_plane_usage FOR
    (geometric_tolerance);
WHERE
  WR1:  SIZEOF( QUERY( gt <* geometric_tolerance |
              SIZEOF( QUERY( sar <* USEDIN(gt.toleranced_shape_aspect,
                      'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_RELATIONSHIP.' +
                      'RELATING_SHAPE_ASPECT') |
               sar.name = 'affected plane association'
               )) > 1
              )) = 0;   
  WR2:  SIZEOF( QUERY( gt <* geometric_tolerance |
              SIZEOF( QUERY( sar <* USEDIN(gt.toleranced_shape_aspect,'AUTOMOTIVE_DESIGN.' +
                      'SHAPE_ASPECT_RELATIONSHIP.RELATING_SHAPE_ASPECT') |
               (sar.name = 'affected plane association') AND
               NOT (SIZEOF(['AUTOMOTIVE_DESIGN.LINE_PROFILE_TOLERANCE',
                            'AUTOMOTIVE_DESIGN.PARALLELISM_TOLERANCE',
                            'AUTOMOTIVE_DESIGN.PERPENDICULARITY_TOLERANCE',
                            'AUTOMOTIVE_DESIGN.POSITION_TOLERANCE',
                            'AUTOMOTIVE_DESIGN.STRAIGHTNESS_TOLERANCE',
                            'AUTOMOTIVE_DESIGN.SYMMETRY_TOLERANCE'] *
                            TYPEOF(gt)
                     ) <> 1)
               )) > 0
              )) = 0;   
END_RULE;
(*

Argument definitions:

geometric_tolerance: the set of all instances of geometric_tolerance.

Formal propositions

WR1: The toleranced_shape_aspect of each instance of geometric_tolerance shall be refered to as relating_shape_aspect by at most one shape_aspect_relationship that has a name of 'affected plane association'.

WR2: The toleranced_shape_aspect of an instance of geometric_tolerance shall only be refered to as relating_shape_aspect by a shape_aspect_relationship with a name of 'affected plane association' if the geometric_tolerance is of type{line_profile_tolerance}, parallelism_tolerance, perpendicularity_tolerance, position_tolerance, straightness_tolerance, or symmetry_tolerance.

5.2.4.209 restrict_zone_boundary

The restrict_zone_boundary rule ensures that a Tolerance_zone_definition is unambiguously defined.
*)
RULE restrict_zone_boundary FOR
    (tolerance_zone_definition);
WHERE
  WR1:  SIZEOF( QUERY( tzd <* tolerance_zone_definition |
              SIZEOF(tzd.boundaries) > 2
              )) = 0;   
END_RULE;
(*

Argument definitions:

tolerance_zone_definition: the set of all instances of tolerance_zone_definition.

Formal propositions

WR1: Each instance of tolerance_zone_definition shall refer to at most two shape_aspects as boundaries.

5.2.4.210 retention_requires_retention_assignment

The retention_requires_retention_assignment rule specifies that each instance of retention is referenced by at least one instance of applied_action_assignment as the assigned_action, where the role of this applied_action_assignment is 'retention'. This rule enforces the requirement for every instance of Retention_period to be applied at least once.
*)
RULE retention_requires_retention_assignment FOR
    (retention);
WHERE
  WR1:  SIZEOF( QUERY( r <* retention |
                SIZEOF( QUERY( aa <* USEDIN( r, 'AUTOMOTIVE_DESIGN.' +
                                     'ACTION_ASSIGNMENT.ASSIGNED_ACTION') |
                        ('AUTOMOTIVE_DESIGN.APPLIED_ACTION_ASSIGNMENT' IN
                         TYPEOF(aa)) AND (aa.role.name = 'retention' ))) = 0
              )) = 0;
              
END_RULE;
(*

Argument definitions:

retention: the set of all instances of retention.

Formal propositions

WR1: Each instance of retention shall be referenced at least once as the assigned_action by an instance of applied_action_assignment, where the name of the object_role of this applied_action_assignment is 'retention'.

5.2.4.211 security_classification_requires_security_classification_assignment

The security_classification_requires_security_classification_assignment rule specifies that each instance of security_classification is referenced by at least one instance of security_classification_assignment as the assigned_security_classification. This rule enforces the requirement for every Security_classification to be applied at least once.
*)
RULE security_classification_requires_security_classification_assignment FOR
    (security_classification);
WHERE
  WR1:  SIZEOF( QUERY( sc <* security_classification |
               SIZEOF( USEDIN(sc,'AUTOMOTIVE_DESIGN.' +
                      'SECURITY_CLASSIFICATION_ASSIGNMENT.ASSIGNED_SECURITY_CLASSIFICATION')
                ) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

security_classification: the set of all instances of security_classification.

Formal propositions

WR1: Each instance of security_classification shall be used at least once as the assigned_security_classification by an instance of security_classification_assignment.

5.2.4.212 selected_instance_usage_requires_representation

The selected_instance_usage_requires_representation rule specifies that each instance of assembly_component_usage which has a name of 'selected instance usage' shall be represented by a representation with a name of 'selection criteria' containing two representation_items describing the constraints the quantity of the related_product_definition depends on.
*)
RULE selected_instance_usage_requires_representation FOR
    (assembly_component_usage,
     representation);
WHERE
  WR1:  SIZEOF( QUERY( acr <* assembly_component_usage |
               (acr.name = 'selected instance usage') AND
               (SIZEOF( QUERY( pd <* USEDIN(acr,'AUTOMOTIVE_DESIGN.' +
                        'PROPERTY_DEFINITION.DEFINITION') |
                  (pd.name = 'occurrence selection') AND
                  (SIZEOF( QUERY( pdr <* USEDIN(pd,'AUTOMOTIVE_DESIGN.' +
                           'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') |
                     (pdr.used_representation.name = 'selection criteria') AND
                     (SIZEOF(pdr.used_representation.items) = 2) AND
                     (SIZEOF( QUERY( i <* pdr.used_representation.items |
                        (SIZEOF(['AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                                 'AUTOMOTIVE_DESIGN.VALUE_RANGE'] *
                                 TYPEOF(i)) = 1 ) AND
                        (i.name = 'selection quantity') 
                       )) = 1 ) AND
                     (SIZEOF( QUERY( i <* pdr.used_representation.items |
                        ('AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN 
                         TYPEOF(i)) AND
                        (i.name = 'selection control') 
                       )) = 1) 
                   )) > 0)
                 )) = 0 ) 
              )) = 0; 
              
END_RULE;
(*

Argument definitions:

assembly_component_usage: the set of all instances of assembly_component_usage.

representation: the set of all instances of representation.

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of assembly_component_relationship which has a name of 'selected instance usage' shall be referenced by a property_definition which has a name of 'occurrence selection', and which is referenced as definition by a property_definition_representation which has as used_representation a representation which has a name of 'selection criteria' and which contains exactly two representation_items in its set of items. One of these representation_items shall be of type measure_representation_item or value_range and shall have a name of 'selection quantity'. The other one of these representation_items shall be of type descriptive_representation_item and shall have a name of 'selection control'.

5.2.4.213 sheets_belong_to_one_drawing

The sheets_belong_to_one_drawing rule ensures that each drawing_sheet_revision belongs to exactly one drawing_revision.
*)
RULE sheets_belong_to_one_drawing FOR
    (drawing_sheet_revision);
WHERE
  WR1:  SIZEOF (QUERY (dsr <* drawing_sheet_revision |
              SIZEOF (QUERY (dsru <* USEDIN(dsr,'AUTOMOTIVE_DESIGN.AREA_IN_SET.AREA') |
               ('AUTOMOTIVE_DESIGN.DRAWING_SHEET_REVISION_USAGE' IN
                TYPEOF(dsru)) 
               )) <> 1
              ))=0;   
END_RULE;
(*

Argument definitions:

drawing_sheet_revision: the set of all instances of drawing_sheet_revision.

Formal propositions

WR1: For each instance of drawing_sheet_revision there shall be exactly one instance of drawing_sheet_revision_usage which contains the instance of drawing_sheet_revision as its area attribute.

5.2.4.214 styled_curve

The styled_curve rule ensures that a styled_item that gives the style for a curve specifies a single curve_style.
*)
RULE styled_curve FOR
    (styled_item);
WHERE
  WR1:  SIZEOF( QUERY( si <* styled_item |
              ('AUTOMOTIVE_DESIGN.CURVE' IN TYPEOF (si.item)) AND
              (SIZEOF (QUERY (psa <* si.styles |
                (SIZEOF (QUERY (cs <* psa.styles |
                  ('AUTOMOTIVE_DESIGN.CURVE_STYLE' IN 
                   TYPEOF (cs))
                  )) > 0)
                )) <> 1)
              )) = 0;
           
END_RULE;
(*

Argument definitions:

styled_item: the set of all instances of styled_item.

Formal propositions

WR1: Every styled_item that provides the style for a curve shall have exactly one style that is a curve_style.

5.2.4.215 subtype_exclusiveness_action

The subtype_exclusiveness_action rule specifies that the subtypes of action are mutually exclusive.
*)
RULE subtype_exclusiveness_action FOR
    (action);
WHERE
  WR1:  SIZEOF(QUERY ( a <* action |
                    NOT (type_check_function(a,
                       ['AUTOMOTIVE_DESIGN.ELEMENT_DELIVERY',
                        'AUTOMOTIVE_DESIGN.EXECUTED_ACTION',
                        'AUTOMOTIVE_DESIGN.PROCESS_PLAN',
                        'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_PROCESS',
                        'AUTOMOTIVE_DESIGN.PROPERTY_PROCESS',
                        'AUTOMOTIVE_DESIGN.RETENTION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

action: the set of all instances of action.

Formal propositions

WR1: Each instance of the subtypes of an action shall be only one of element_delivery, executed_action, process_plan, product_definition_process, property_process, retention.

5.2.4.216 subtype_exclusiveness_characterized_object

The subtype_exclusiveness_characterized_object rule specifies that the subtypes of characterized_object are mutually exclusive.
*)
RULE subtype_exclusiveness_characterized_object FOR
    (characterized_object);
WHERE
  WR1:  SIZEOF(QUERY (co <* characterized_object |
                    NOT (type_check_function(co,
                       ['AUTOMOTIVE_DESIGN.CHARACTERIZED_CLASS',
                        'AUTOMOTIVE_DESIGN.DOCUMENT_FILE',
                        'AUTOMOTIVE_DESIGN.FEATURE_COMPONENT_DEFINITION',
                        'AUTOMOTIVE_DESIGN.FEATURE_DEFINITION',
                        'AUTOMOTIVE_DESIGN.PRODUCT_CLASS',
                        'AUTOMOTIVE_DESIGN.PRODUCT_IDENTIFICATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

characterized_object: the set of all instances of characterized_object.

Formal propositions

WR1: Each instance of the subtypes of an characterized_object shall be only one of characterized_class, document_file, feature_component_definition, feature_definition, product_class, product_identification.

5.2.4.217 subtype_exclusiveness_classification_assignment

The subtype_exclusiveness_classification_assignment rule specifies that the subtypes of classification_assignment are mutually exclusive.
*)
RULE subtype_exclusiveness_classification_assignment FOR
    (classification_assignment);
WHERE
  WR1:  SIZEOF(QUERY (ca <* classification_assignment |
                    NOT (type_check_function(ca,
                       ['AUTOMOTIVE_DESIGN.APPLIED_CLASSIFICATION_ASSIGNMENT',
                        'AUTOMOTIVE_DESIGN.LANGUAGE_ASSIGNMENT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

classification_assignment: the set of all instances of classification_assignment.

Formal propositions

WR1: Each instance of the subtypes of an classification_assignment shall be only one of applied_classification_assignment, language_assignment.

5.2.4.218 subtype_exclusiveness_colour

The subtype_exclusiveness_colour rule specifies that the subtypes of colour are mutually exclusive, except for background_colour.
*)
RULE subtype_exclusiveness_colour FOR
    (colour);
WHERE
  WR1:  SIZEOF(QUERY (c <* colour |
                    NOT (type_check_function(c,
                       ['AUTOMOTIVE_DESIGN.COLOUR_SPECIFICATION',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_COLOUR'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

colour: the set of all instances of colour.

Formal propositions

WR1: Each instance of the subtypes of an colour shall be only one of colour_specification, pre_defined_colour.

5.2.4.219 subtype_exclusiveness_compound_representation_item

The subtype_exclusiveness_compound_representation_item rule specifies that the subtypes of compound_representation_item are mutually exclusive.
*)
RULE subtype_exclusiveness_compound_representation_item FOR
    (compound_representation_item);
WHERE
  WR1:  SIZEOF(QUERY (cri <* compound_representation_item |
                    NOT (type_check_function(cri,
                       ['AUTOMOTIVE_DESIGN.DEFAULT_TOLERANCE_TABLE_CELL',
                        'AUTOMOTIVE_DESIGN.VALUE_RANGE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

compound_representation_item: the set of all instances of compound_representation_item.

Formal propositions

WR1: Each instance of the subtypes of an compound_representation_item shall be only one of default_tolerance_table_cell, value_range.

5.2.4.220 subtype_exclusiveness_document_reference

The subtype_exclusiveness_document_reference rule specifies that the subtypes of document_reference are mutually exclusive.
*)
RULE subtype_exclusiveness_document_reference FOR
    (document_reference);
WHERE
  WR1:  SIZEOF(QUERY (dr <* document_reference |
                    NOT (type_check_function(dr,
                       ['AUTOMOTIVE_DESIGN.APPLIED_DOCUMENT_REFERENCE',
                        'AUTOMOTIVE_DESIGN.DRAUGHTING_SPECIFICATION_REFERENCE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

document_reference: the set of all instances of document_reference.

Formal propositions

WR1: Each instance of the subtypes of an document_reference shall be only one of applied_document_reference, draughting_specification_reference.

5.2.4.221 subtype_exclusiveness_effectivity

The subtype_exclusiveness_effectivity rule specifies that the subtypes of effectivity are mutually exclusive, except for dated_effectivity, lot_effectivity, and serial_numbered_effectivity.
*)
RULE subtype_exclusiveness_effectivity FOR
    (effectivity);
WHERE
  WR1:  SIZEOF(QUERY (e <* effectivity |
                    NOT (type_check_function(e,
                       ['AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_EFFECTIVITY',
                        'AUTOMOTIVE_DESIGN.TIME_INTERVAL_BASED_EFFECTIVITY'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

effectivity: the set of all instances of effectivity.

Formal propositions

WR1: Each instance of the subtypes of an effectivity shall be only one of product_definition_effectivity, time_interval_based_effectivity.

5.2.4.222 subtype_exclusiveness_effectivity_assignment

The subtype_exclusiveness_effectivity_assignment rule specifies that the subtypes of effectivity_assignment are mutually exclusive.
*)
RULE subtype_exclusiveness_effectivity_assignment FOR
    (effectivity_assignment);
WHERE
  WR1:  SIZEOF(QUERY (ea <* effectivity_assignment |
                    NOT (type_check_function(ea,
                       ['AUTOMOTIVE_DESIGN.APPLIED_EFFECTIVITY_ASSIGNMENT',
                        'AUTOMOTIVE_DESIGN.APPLIED_INEFFECTIVITY_ASSIGNMENT',
                        'AUTOMOTIVE_DESIGN.CONFIGURED_EFFECTIVITY_ASSIGNMENT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

effectivity_assignment: the set of all instances of effectivity_assignment.

Formal propositions

WR1: Each instance of the subtypes of an effectivity_assignment shall be only one of applied_effectivity_assignment, applied_ineffectivity_assignment, configured_effectivity_assignment.

5.2.4.223 subtype_exclusiveness_effectivity_context_assignment

The subtype_exclusiveness_effectivity_context_assignment rule specifies that the subtypes of effectivity_context_assignment are mutually exclusive.
*)
RULE subtype_exclusiveness_effectivity_context_assignment FOR
    (effectivity_context_assignment);
WHERE
  WR1:  SIZEOF(QUERY (eca <* effectivity_context_assignment |
                    NOT (type_check_function(eca,
                       ['AUTOMOTIVE_DESIGN.CLASS_USAGE_EFFECTIVITY_CONTEXT_ASSIGNMENT',
                        'AUTOMOTIVE_DESIGN.CONFIGURED_EFFECTIVITY_CONTEXT_ASSIGNMENT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

effectivity_context_assignment: the set of all instances of effectivity_context_assignment.

Formal propositions

WR1: Each instance of the subtypes of an effectivity_context_assignment shall be only one of class_usage_effectivity_context_assignment, configured_effectivity_context_assignment.

5.2.4.224 subtype_exclusiveness_externally_defined_item

The subtype_exclusiveness_externally_defined_item rule specifies that the subtypes of externally_defined_item are mutually exclusive.
*)
RULE subtype_exclusiveness_externally_defined_item FOR
    (externally_defined_item);
WHERE
  WR1:  SIZEOF(QUERY (edi <* externally_defined_item |
                    NOT (type_check_function(edi,
                       ['AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CHARACTER_GLYPH',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CURVE_FONT',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_FEATURE_DEFINITION',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_GENERAL_PROPERTY',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_HATCH_STYLE',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_STYLE',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_SYMBOL',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_TEXT_FONT',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_TILE_STYLE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

externally_defined_item: the set of all instances of externally_defined_item.

Formal propositions

WR1: Each instance of the subtypes of an externally_defined_item shall be only one of externally_defined_character_glyph, externally_defined_class, externally_defined_curve_font, externally_defined_feature_definition, externally_defined_general_property, externally_defined_hatch_style, externally_defined_style, externally_defined_symbol, externally_defined_text_font, externally_defined_tile_style.

5.2.4.225 subtype_exclusiveness_feature_component_relationship

The subtype_exclusiveness_feature_component_relationship rule specifies that the subtypes of feature_component_relationship are mutually exclusive.
*)
RULE subtype_exclusiveness_feature_component_relationship FOR
    (feature_component_relationship);
WHERE
  WR1:  SIZEOF(QUERY (fcr <* feature_component_relationship |
                    NOT (type_check_function(fcr,
                       ['AUTOMOTIVE_DESIGN.PATTERN_OFFSET_MEMBERSHIP',
                        'AUTOMOTIVE_DESIGN.PATTERN_OMIT_MEMBERSHIP'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

feature_component_relationship: the set of all instances of feature_component_relationship.

Formal propositions

WR1: Each instance of the subtypes of an feature_component_relationship shall be only one of pattern_offset_membership, pattern_omit_membership.

5.2.4.226 subtype_exclusiveness_feature_definition

The subtype_exclusiveness_feature_definition rule specifies that the subtypes of feature_definition are mutually exclusive, except for instanced_feature.
*)
RULE subtype_exclusiveness_feature_definition FOR
    (feature_definition);
WHERE
  WR1:  SIZEOF(QUERY (fd <* feature_definition |
                    NOT (type_check_function(fd,
                    ['AUTOMOTIVE_DESIGN.BARRING_HOLE',
                     'AUTOMOTIVE_DESIGN.BEAD',
                     'AUTOMOTIVE_DESIGN.BOSS',
                     'AUTOMOTIVE_DESIGN.COMPOUND_FEATURE',
                     'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_FEATURE_DEFINITION',
                     'AUTOMOTIVE_DESIGN.FEATURE_IN_PANEL',
                     'AUTOMOTIVE_DESIGN.GENERAL_FEATURE',
                     'AUTOMOTIVE_DESIGN.HOLE_IN_PANEL',
                     'AUTOMOTIVE_DESIGN.JOGGLE',
                     'AUTOMOTIVE_DESIGN.LOCATOR',
                     'AUTOMOTIVE_DESIGN.POCKET',
                     'AUTOMOTIVE_DESIGN.RIB',
                     'AUTOMOTIVE_DESIGN.ROUND_HOLE',
                     'AUTOMOTIVE_DESIGN.SLOT',
                     'AUTOMOTIVE_DESIGN.THREAD'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

feature_definition: the set of all instances of feature_definition.

Formal propositions

WR1: Each instance of the subtypes of an feature_definition shall be only one of barring_hole, bead, boss, compound_feature, externally_defined_feature_definition, feature_in_panel, general_feature, hole_in_panel, joggle, locator, pocket, rib, round_hole, slot, thread.

5.2.4.227 subtype_exclusiveness_founded_item

The subtype_exclusiveness_founded_item rule specifies that the subtypes of founded_item are mutually exclusive.
*)
RULE subtype_exclusiveness_founded_item FOR
    (founded_item);
WHERE
  WR1:  SIZEOF(QUERY (fi <* founded_item |
                    NOT (type_check_function(fi,
                    ['AUTOMOTIVE_DESIGN.COMPOSITE_CURVE_SEGMENT',
                     'AUTOMOTIVE_DESIGN.SURFACE_PATCH',
                     'AUTOMOTIVE_DESIGN.VIEW_VOLUME'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

founded_item: the set of all instances of founded_item.

Formal propositions

WR1: Each instance of the subtypes of an founded_item shall be only one of composite_curve_segment, surface_patch, view_volume.

5.2.4.228 subtype_exclusiveness_geometric_tolerance

The subtype_exclusiveness_geometric_tolerance rule specifies that an instance of the subtypes of a geometric_tolerance shall be exactly one of angularity_tolerance, circular_runout_tolerance, concentricity_tolerance, cylindricity_tolerance, flatness_tolerance, line_profile_tolerance, parallelism_tolerance, perpendicularity_tolerance, position_tolerance, roundness_tolerance, straightness_tolerance, surface_profile_tolerance, symmetry_tolerance, or total_runout_tolerance.
*)
RULE subtype_exclusiveness_geometric_tolerance FOR
    (geometric_tolerance);
WHERE
  WR1:  SIZEOF(QUERY (gt <* geometric_tolerance |
                    NOT (type_check_function(gt,
                    ['AUTOMOTIVE_DESIGN.ANGULARITY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.CIRCULAR_RUNOUT_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.COAXIALITY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.CONCENTRICITY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.CYLINDRICITY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.FLATNESS_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.LINE_PROFILE_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.PARALLELISM_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.PERPENDICULARITY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.POSITION_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.ROUNDNESS_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.STRAIGHTNESS_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.SURFACE_PROFILE_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.SYMMETRY_TOLERANCE',
                     'AUTOMOTIVE_DESIGN.TOTAL_RUNOUT_TOLERANCE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

geometric_tolerance: the set of all instances of geometric_tolerance.

Formal propositions

WR1: Each instance of the subtypes of geometric_tolerance shall be exactly one of angularity_tolerance, circular_runout_tolerance, coaxiality_tolerance, concentricity_tolerance, cylindricity_tolerance, flatness_tolerance, line_profile_tolerance, parallelism_tolerance, perpendicularity_tolerance, position_tolerance, roundness_tolerance, straightness_tolerance, surface_profile_tolerance, symmetry_tolerance, or total_runout_tolerance.

5.2.4.229 subtype_exclusiveness_group

The subtype_exclusiveness_group rule specifies that the subtypes of group are mutually exclusive.
*)
RULE subtype_exclusiveness_group FOR
    (group);
WHERE
  WR1:  SIZEOF(QUERY (g <* group |
                    NOT (type_check_function(g,
                    ['AUTOMOTIVE_DESIGN.CLASS',
                     'AUTOMOTIVE_DESIGN.CLASS_SYSTEM',
                     'AUTOMOTIVE_DESIGN.LANGUAGE',
                     'AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY',
                     'AUTOMOTIVE_DESIGN.REP_ITEM_GROUP'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

group: the set of all instances of group.

Formal propositions

WR1: Each instance of the subtypes of an group shall be only one of class, class_system, language, product_concept_feature_category, rep_item_group.

5.2.4.230 subtype_exclusiveness_group_assignment

The subtype_exclusiveness_group_assignment rule specifies that the subtypes of group_assignment are mutually exclusive.
*)
RULE subtype_exclusiveness_group_assignment FOR
    (group_assignment);
WHERE
  WR1:  SIZEOF(QUERY (ga <* group_assignment |
                    NOT (type_check_function(ga,
                    ['AUTOMOTIVE_DESIGN.APPLIED_GROUP_ASSIGNMENT',
                    'AUTOMOTIVE_DESIGN.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

group_assignment: the set of all instances of group_assignment.

Formal propositions

WR1: Each instance of the subtypes of an group_assignment shall be only one of applied_group_assignment, product_concept_feature_category_usage.

5.2.4.231 subtype_exclusiveness_identification_assignment

The subtype_exclusiveness_identification_assignment rule specifies that the subtypes of identification_assignment are mutually exclusive.
*)
RULE subtype_exclusiveness_identification_assignment FOR
    (identification_assignment);
WHERE
  WR1:  SIZEOF(QUERY (ia <* identification_assignment |
                    NOT (type_check_function(ia,
                       ['AUTOMOTIVE_DESIGN.APPLIED_IDENTIFICATION_ASSIGNMENT',
                        'AUTOMOTIVE_DESIGN.EXTERNAL_IDENTIFICATION_ASSIGNMENT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

identification_assignment: the set of all instances of identification_assignment.

Formal propositions

WR1: Each instance of the subtypes of an identification_assignment shall be only one of applied_identification_assignment, external_identification_assignment.

5.2.4.232 subtype_exclusiveness_mapped_item

The subtype_exclusiveness_mapped_item rule specifies that the subtypes of mapped_item are mutually exclusive.
*)
RULE subtype_exclusiveness_mapped_item FOR
    (mapped_item);
WHERE
  WR1:  SIZEOF(QUERY (mi <* mapped_item |
                    NOT (type_check_function(mi,
                       ['AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL',
                        'AUTOMOTIVE_DESIGN.ANNOTATION_TEXT',
                        'AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_CHARACTER',
                        'AUTOMOTIVE_DESIGN.CAMERA_IMAGE',
                        'AUTOMOTIVE_DESIGN.DIMENSION_TEXT_ASSOCIATIVITY'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

mapped_item: the set of all instances of mapped_item.

Formal propositions

WR1: Each instance of the subtypes of an mapped_item shall be only one of annotation_symbol, annotation_text, annotation_text_character, camera_image, dimension_text_associativity.

5.2.4.233 subtype_exclusiveness_pre_defined_item

The subtype_exclusiveness_pre_defined_item rule specifies that the subtypes of pre_defined_item are mutually exclusive.
*)
RULE subtype_exclusiveness_pre_defined_item FOR
    (pre_defined_item);
WHERE
  WR1:  SIZEOF(QUERY (pdi <* pre_defined_item |
                    NOT (type_check_function(pdi,
                       ['AUTOMOTIVE_DESIGN.KNOWN_SOURCE',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_COLOUR',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_CURVE_FONT',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_MARKER',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_PRESENTATION_STYLE',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_TEXT_FONT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_item: the set of all instances of pre_defined_item.

Formal propositions

WR1: Each instance of the subtypes of an pre_defined_item shall be only one of known_source, pre_defined_colour, pre_defined_curve_font, pre_defined_marker, pre_defined_presentation_style, pre_defined_symbol, pre_defined_text_font.

5.2.4.234 subtype_exclusiveness_pre_defined_symbol

The subtype_exclusiveness_pre_defined_symbol rule specifies that the subtypes of pre_defined_symbol are mutually exclusive.
*)
RULE subtype_exclusiveness_pre_defined_symbol FOR
    (pre_defined_symbol);
WHERE
  WR1:  SIZEOF(QUERY (pds <* pre_defined_symbol |
                    NOT (type_check_function(pds,
                       ['AUTOMOTIVE_DESIGN.PRE_DEFINED_DIMENSION_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_POINT_MARKER_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_SURFACE_CONDITION_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_TERMINATOR_SYMBOL'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_symbol: the set of all instances of pre_defined_symbol.

Formal propositions

WR1: Each instance of the subtypes of an pre_defined_symbol shall be only one of pre_defined_dimension_symbol, pre_defined_geometrical_tolerance_symbol, pre_defined_point_marker_symbol, pre_defined_surface_condition_symbol, pre_defined_terminator_symbol.

5.2.4.235 subtype_exclusiveness_presentation_area

The subtype_exclusiveness_presentation_area rule specifies that the subtypes of presentation_area are mutually exclusive.
*)
RULE subtype_exclusiveness_presentation_area FOR
    (presentation_area);
WHERE
  WR1:  SIZEOF(QUERY (pa <* presentation_area |
                    NOT (type_check_function(pa,
                       ['AUTOMOTIVE_DESIGN.DRAWING_SHEET_REVISION',
                        'AUTOMOTIVE_DESIGN.MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_AREA'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

presentation_area: the set of all instances of presentation_area.

Formal propositions

WR1: Each instance of the subtypes of an presentation_area shall be only one of drawing_sheet_revision, mechanical_design_geometric_presentation_area.

5.2.4.236 subtype_exclusiveness_presentation_representation

The subtype_exclusiveness_presentation_representation rule specifies that the subtypes of presentation_representation are mutually exclusive.
*)
RULE subtype_exclusiveness_presentation_representation FOR
    (presentation_representation);
WHERE
  WR1:  SIZEOF(QUERY (pr <* presentation_representation |
                    NOT (type_check_function(pr,
                       ['AUTOMOTIVE_DESIGN.PRESENTATION_AREA',
                        'AUTOMOTIVE_DESIGN.PRESENTATION_VIEW'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

presentation_representation: the set of all instances of presentation_representation.

Formal propositions

WR1: Each instance of the subtypes of an presentation_representation shall be only one of presentation_area, presentation_view.

5.2.4.237 subtype_exclusiveness_property_definition

The subtype_exclusiveness_property_definition rule specifies that the subtypes of property_definition are mutually exclusive.
*)
RULE subtype_exclusiveness_property_definition FOR
    (property_definition);
WHERE
  WR1:  SIZEOF(QUERY (pd <* property_definition |
                    NOT (type_check_function(pd,
                       ['AUTOMOTIVE_DESIGN.KINEMATIC_PROPERTY_DEFINITION',
                        'AUTOMOTIVE_DESIGN.MATERIAL_PROPERTY',
                        'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_SHAPE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

property_definition: the set of all instances of property_definition.

Formal propositions

WR1: Each instance of the subtypes of an property_definition shall be only one of kinematic_property_definition, material_property, product_definition_shape.

5.2.4.238 subtype_exclusiveness_property_definition_representation

The subtype_exclusiveness_property_definition_representation rule specifies that the subtypes of property_definition_representation are mutually exclusive.
*)
RULE subtype_exclusiveness_property_definition_representation FOR
    (property_definition_representation);
WHERE
  WR1:  SIZEOF(QUERY (pdr <* property_definition_representation |
                    NOT (type_check_function(pdr,
                       ['AUTOMOTIVE_DESIGN.KINEMATIC_PROPERTY_REPRESENTATION_RELATION',
                        'AUTOMOTIVE_DESIGN.MATERIAL_PROPERTY_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.SHAPE_DEFINITION_REPRESENTATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

property_definition_representation: the set of all instances of property_definition_representation.

Formal propositions

WR1: Each instance of the subtypes of an property_definition_representation shall be only one of kinematic_property_representation_relation, material_property_representation, shape_definition_representation.

5.2.4.239 subtype_exclusiveness_replicate_feature

The subtype_exclusiveness_replicate_feature rule specifies that the subtypes of replicate_feature are mutually exclusive.
*)
RULE subtype_exclusiveness_replicate_feature FOR
    (replicate_feature);
WHERE
  WR1:  SIZEOF(QUERY (rf <* replicate_feature |
                    NOT (type_check_function(rf,
                       ['AUTOMOTIVE_DESIGN.CIRCULAR_PATTERN',
                        'AUTOMOTIVE_DESIGN.FEATURE_PATTERN',
                        'AUTOMOTIVE_DESIGN.MODIFIED_PATTERN',
                        'AUTOMOTIVE_DESIGN.RECTANGULAR_PATTERN'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

replicate_feature: the set of all instances of replicate_feature.

Formal propositions

WR1: Each instance of the subtypes of an replicate_feature shall be only one of circular_pattern, feature_pattern, modified_pattern, rectangular_pattern.

5.2.4.240 subtype_exclusiveness_representation

The subtype_exclusiveness_representation rule specifies that the subtypes of representation are mutually exclusive, except for uncertainty_assigned_representation.
*)
RULE subtype_exclusiveness_representation FOR
    (representation);
WHERE
  WR1:  SIZEOF(QUERY (r <* representation |
                    NOT (type_check_function(r,
                       ['AUTOMOTIVE_DESIGN.CONSTRUCTIVE_GEOMETRY_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.CONTACT_RATIO_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.DEFAULT_TOLERANCE_TABLE',
                        'AUTOMOTIVE_DESIGN.DEFINITIONAL_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.DIRECTION_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.DRAUGHTING_MODEL',
                        'AUTOMOTIVE_DESIGN.FOUNDED_KINEMATIC_PATH',
                        'AUTOMOTIVE_DESIGN.HARDNESS_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.KINEMATIC_FRAME_BACKGROUND_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.KINEMATIC_GROUND_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.MOMENTS_OF_INERTIA_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.PRESENTATION_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.SURFACE_TEXTURE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.SYMBOL_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.TACTILE_APPEARANCE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.TEXT_STRING_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.VISUAL_APPEARANCE_REPRESENTATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

representation: the set of all instances of representation.

Formal propositions

WR1: Each instance of the subtypes of an representation shall be only one of constructive_geometry_representation, contact_ratio_representation, default_tolerance_table, definitional_representation, direction_shape_representation, draughting_model, founded_kinematic_path, hardness_representation, kinematic_frame_background_representation, kinematic_ground_representation, kinematic_link_representation, mechanical_design_geometric_presentation_representation, moments_of_inertia_representation, presentation_representation, shape_representation, surface_texture_representation, symbol_representation, tactile_appearance_representation, text_string_representation, visual_appearance_representation.

5.2.4.241 subtype_exclusiveness_representation_item

The subtype_exclusiveness_representation_item rule specifies that the subtypes of representation_item are mutually exclusive, except for geometric_representation_item, mapped_item, qualified_representation_item, styled_item, and topological_representation_item.
*)
RULE subtype_exclusiveness_representation_item FOR
    (representation_item);
WHERE
  WR1:  SIZEOF(QUERY (ri <* representation_item |
                    NOT (type_check_function(ri,
                       ['AUTOMOTIVE_DESIGN.COMPOUND_REPRESENTATION_ITEM',
                        
,
                        'AUTOMOTIVE_DESIGN.KINEMATIC_PATH',
                        'AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM',
                        'AUTOMOTIVE_DESIGN.REP_ITEM_GROUP',
                        'AUTOMOTIVE_DESIGN.VALUE_REPRESENTATION_ITEM'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

representation_item: the set of all instances of representation_item.

Formal propositions

WR1: Each instance of the subtypes of an representation_item shall be only one of compound_representation_item, kinematic_path, measure_representation_item, rep_item_group, value_representation_item.

5.2.4.242 subtype_exclusiveness_representation_map

The subtype_exclusiveness_representation_map rule specifies that the subtypes of representation_map are mutually exclusive.
*)
RULE subtype_exclusiveness_representation_map FOR
    (representation_map);
WHERE
  WR1:  SIZEOF(QUERY (rm <* representation_map |
                    NOT (type_check_function(rm,
                       ['AUTOMOTIVE_DESIGN.CAMERA_USAGE',
                        'AUTOMOTIVE_DESIGN.SYMBOL_REPRESENTATION_MAP'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

representation_map: the set of all instances of representation_map.

Formal propositions

WR1: Each instance of the subtypes of an representation_map shall be only one of camera_usage, symbol_representation_map.

5.2.4.243 subtype_exclusiveness_representation_relationship

The subtype_exclusiveness_representation_relationship rule specifies that the subtypes of representation_relationship are mutually exclusive, except for representation_relationship_with_transformation and shape_representation_relationship.
*)
RULE subtype_exclusiveness_representation_relationship FOR
    (representation_relationship);
WHERE
  WR1:  SIZEOF(QUERY (rr <* representation_relationship |
                    NOT (type_check_function(rr,
                       ['AUTOMOTIVE_DESIGN.CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP',
                        'AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION_ASSOCIATION',
                        'AUTOMOTIVE_DESIGN.MOTION_LINK_RELATIONSHIP'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

representation_relationship: the set of all instances of representation_relationship.

Formal propositions

WR1: Each instance of the subtypes of an representation_relationship shall be only one of constructive_geometry_representation_relationship, kinematic_link_representation_association, motion_link_relationship.

5.2.4.244 subtype_exclusiveness_representation_relationship_with_transformation

The subtype_exclusiveness_representation_relationship_with_transformation rule specifies that the subtypes of representation_relationship_with_transformation are mutually exclusive.
*)
RULE subtype_exclusiveness_representation_relationship_with_transformation FOR
    (representation_relationship_with_transformation);
WHERE
  WR1:  SIZEOF(QUERY (rrwt <* representation_relationship_with_transformation |
                    NOT (type_check_function(rrwt,
                       ['AUTOMOTIVE_DESIGN.KINEMATIC_FRAME_BACKGROUND_REPRESENTATION_ASSOCIATION',
                        'AUTOMOTIVE_DESIGN.MECHANISM_BASE_PLACEMENT'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

representation_relationship_with_transformation: the set of all instances of representation_relationship_with_transformation.

Formal propositions

WR1: Each instance of the subtypes of an representation_relationship_with_transformation shall be only one of kinematic_frame_background_representation_association, mechanism_base_placement.

5.2.4.245 subtype_exclusiveness_shape_aspect

The subtype_exclusiveness_shape_aspect rule specifies that the subtypes of shape_aspect are mutually exclusive, except for composite_shape_aspect, datum, datum_feature, datum_target, derived_shape_aspect, and symmetric_shape_aspect.
*)
RULE subtype_exclusiveness_shape_aspect FOR
    (shape_aspect);
WHERE
  WR1:  SIZEOF(QUERY (sa <* shape_aspect |
                    NOT (type_check_function(sa,
                       ['AUTOMOTIVE_DESIGN.APPLIED_AREA',
                        'AUTOMOTIVE_DESIGN.BEAD_END',
                        'AUTOMOTIVE_DESIGN.BOSS_TOP',
                        'AUTOMOTIVE_DESIGN.CHAMFER_OFFSET',
                        'AUTOMOTIVE_DESIGN.CIRCULAR_CLOSED_PROFILE',
                        'AUTOMOTIVE_DESIGN.CLOSED_PATH_PROFILE',
                        'AUTOMOTIVE_DESIGN.DIRECTED_ANGLE',
                        'AUTOMOTIVE_DESIGN.HOLE_BOTTOM',
                        'AUTOMOTIVE_DESIGN.INSTANCED_FEATURE',
                        'AUTOMOTIVE_DESIGN.JOGGLE_TERMINATION',
                        'AUTOMOTIVE_DESIGN.NGON_CLOSED_PROFILE',
                        'AUTOMOTIVE_DESIGN.OPEN_PATH_PROFILE',
                        'AUTOMOTIVE_DESIGN.PARTIAL_CIRCULAR_PROFILE',
                        'AUTOMOTIVE_DESIGN.PATH_FEATURE_COMPONENT',
                        'AUTOMOTIVE_DESIGN.PLACED_FEATURE',
                        'AUTOMOTIVE_DESIGN.POCKET_BOTTOM',
                        'AUTOMOTIVE_DESIGN.RECTANGULAR_CLOSED_PROFILE',
                        'AUTOMOTIVE_DESIGN.REPLICATE_FEATURE',
                        'AUTOMOTIVE_DESIGN.ROUNDED_U_PROFILE',
                        'AUTOMOTIVE_DESIGN.SLOT_END',
                        'AUTOMOTIVE_DESIGN.SQUARE_U_PROFILE',
                        'AUTOMOTIVE_DESIGN.TAPER',
                        'AUTOMOTIVE_DESIGN.TEE_PROFILE',
                        'AUTOMOTIVE_DESIGN.THREAD_OCCURRENCE',
                        'AUTOMOTIVE_DESIGN.TOLERANCE_ZONE',
                        'AUTOMOTIVE_DESIGN.TRANSITION_FEATURE',
                        'AUTOMOTIVE_DESIGN.VEE_PROFILE'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

shape_aspect: the set of all instances of shape_aspect.

Formal propositions

WR1: Each instance of the subtypes of an shape_aspect shall be only one of applied_area, bead_end, boss_top, chamfer_offset, circular_closed_profile, closed_path_profile, directed_angle, hole_bottom, instanced_feature, joggle_termination, ngon_closed_profile, open_path_profile, partial_circular_profile, path_feature_component, placed_feature, pocket_bottom, rectangular_closed_profile, replicate_feature, rounded_u_profile, slot_end, square_u_profile, taper, tee_profile, thread_occurrence, tolerance_zone, transition_feature, vee_profile.

5.2.4.246 subtype_exclusiveness_shape_aspect_relationship

The subtype_exclusiveness_shape_aspect_relationship rule specifies that the subtypes of shape_aspect_relationship are mutually exclusive.
*)
RULE subtype_exclusiveness_shape_aspect_relationship FOR
    (shape_aspect_relationship);
WHERE
  WR1:  SIZEOF(QUERY (sar <* shape_aspect_relationship |
                    NOT (type_check_function(sar,
                       ['AUTOMOTIVE_DESIGN.DIMENSIONAL_LOCATION',
                        'AUTOMOTIVE_DESIGN.FEATURE_COMPONENT_RELATIONSHIP',
                        'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_ASSOCIATIVITY',
                        'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_DERIVING_RELATIONSHIP',
                        'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_TRANSITION',
                        'AUTOMOTIVE_DESIGN.SHAPE_DEFINING_RELATIONSHIP'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

shape_aspect_relationship: the set of all instances of shape_aspect_relationship.

Formal propositions

WR1: Each instance of the subtypes of an shape_aspect_relationship shall be only one of dimensional_location, feature_component_relationship, shape_aspect_associativity, shape_aspect_deriving_relationship, shape_aspect_transition, shape_defining_relationship.

5.2.4.247 subtype_exclusiveness_shape_representation_feature_geometry

The subtype_exclusiveness_shape_representation_feature_geometry rule specifies that the subtypes of shape_representation are mutually exclusive, except for shape_dimension_representation, shape_representation_with_parameters, and the subtypes covered by the subtype_exclusiveness_shape_representation_geometry rule.
*)
RULE subtype_exclusiveness_shape_representation_feature_geometry FOR
    (shape_representation);
WHERE
  WR1:  SIZEOF(QUERY (sr <* shape_representation |
                    NOT (type_check_function(sr,
                       ['AUTOMOTIVE_DESIGN.DIRECTION_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.FACE_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.LOCATION_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.PATH_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.PLANAR_SHAPE_REPRESENTATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

shape_representation: the set of all instances of shape_representation.

Formal propositions

WR1: Each instance of the subtypes of an shape_representation shall be only one of direction_shape_representation, face_shape_representation, location_shape_representation, path_shape_representation, planar_shape_representation.

5.2.4.248 subtype_exclusiveness_shape_representation_geometry

The subtype_exclusiveness_shape_representation_geometry rule specifies that the subtypes of shape_representation are mutually exclusive, except for shape_dimension_representation, shape_representation_with_parameters, and the subtypes covered by the subtype_exclusiveness_shape_representation_feature_geometry rule.
*)
RULE subtype_exclusiveness_shape_representation_geometry FOR
    (shape_representation);
WHERE
  WR1:  SIZEOF(QUERY (sr <* shape_representation |
                    NOT (type_check_function(sr,
                       ['AUTOMOTIVE_DESIGN.ADVANCED_BREP_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.COMPOUND_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.CSG_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.FACETED_BREP_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.GEOMETRICALLY_BOUNDED_2D_WIREFRAME_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.MANIFOLD_SURFACE_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.NON_MANIFOLD_SURFACE_SHAPE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.POINT_PLACEMENT_SHAPE_REPRESENTATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

shape_representation: the set of all instances of shape_representation.

Formal propositions

WR1: Each instance of the subtypes of an shape_representation shall be only one of advanced_brep_shape_representation, compound_shape_representation, csg_shape_representation, edge_based_wireframe_shape_representation, faceted_brep_shape_representation, geometrically_bounded_2d_wireframe_representation, geometrically_bounded_surface_shape_representation, geometrically_bounded_wireframe_shape_representation, manifold_surface_shape_representation, non_manifold_surface_shape_representation, point_placement_shape_representation.

5.2.4.249 subtype_exclusiveness_symbol_representation

The subtype_exclusiveness_symbol_representation rule specifies that the subtypes of symbol_representation are mutually exclusive.
*)
RULE subtype_exclusiveness_symbol_representation FOR
    (symbol_representation);
WHERE
  WR1:  SIZEOF(QUERY (sr <* symbol_representation |
                    NOT (type_check_function(sr,
                       ['AUTOMOTIVE_DESIGN.CHARACTER_GLYPH_SYMBOL',
                        'AUTOMOTIVE_DESIGN.DRAUGHTING_SUBFIGURE_REPRESENTATION',
                        'AUTOMOTIVE_DESIGN.DRAUGHTING_SYMBOL_REPRESENTATION'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

symbol_representation: the set of all instances of symbol_representation.

Formal propositions

WR1: Each instance of the subtypes of an symbol_representation shall be only one of character_glyph_symbol, draughting_subfigure_representation, draughting_symbol_representation.

5.2.4.250 subtype_exclusiveness_transition_feature

The subtype_exclusiveness_transition_feature rule specifies that the subtypes of transition_feature are mutually exclusive.
*)
RULE subtype_exclusiveness_transition_feature FOR
    (transition_feature);
WHERE
  WR1:  SIZEOF(QUERY (tf <* transition_feature |
                    NOT (type_check_function(tf,
                       ['AUTOMOTIVE_DESIGN.CHAMFER',
                        'AUTOMOTIVE_DESIGN.EDGE_ROUND',
                        'AUTOMOTIVE_DESIGN.FILLET'] , 3 )
               ))) = 0;
END_RULE;
(*

Argument definitions:

transition_feature: the set of all instances of transition_feature.

Formal propositions

WR1: Each instance of the subtypes of an transition_feature shall be only one of chamfer, edge_round, fillet.

5.2.4.251 subtype_mandatory_address

The subtype_mandatory_address rule ensures that all address entities are of type organizational_address and/or personal_address.
*)
RULE subtype_mandatory_address FOR
    (address);
WHERE
  WR1:  SIZEOF(QUERY (a <* address |
                    NOT (type_check_function(a,
                        ['AUTOMOTIVE_DESIGN.ORGANIZATIONAL_ADDRESS',
                         'AUTOMOTIVE_DESIGN.PERSONAL_ADDRESS'] , 0)
               ))) = 0;
END_RULE;
(*

Argument definitions:

address: the set of all instances of address.

Formal propositions

WR1: Each instance of address shall be of type organizational_address and/or personal_address.

5.2.4.252 subtype_mandatory_annotation_occurrence

The subtype_mandatory_annotation_occurrence rule ensures that all annotation_occurrence entities are of type annotation_curve_occurrence, annotation_fill_area_occurrence,annotation_symbol_occurrence, annotation_text_occurrence, and/or draughting_annotation_occurrence.
*)
RULE subtype_mandatory_annotation_occurrence FOR
    (annotation_occurrence);
WHERE
  WR1:  SIZEOF(QUERY (ao <* annotation_occurrence |
                    NOT (type_check_function(ao,
                        ['AUTOMOTIVE_DESIGN.ANNOTATION_CURVE_OCCURRENCE',
                         'AUTOMOTIVE_DESIGN.ANNOTATION_FILL_AREA_OCCURRENCE',
                         'AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL_OCCURRENCE',
                         'AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE',
                         'AUTOMOTIVE_DESIGN.DRAUGHTING_ANNOTATION_OCCURRENCE'] , 0)
                        ))) = 0;
END_RULE;
(*

Argument definitions:

annotation_occurrence: the set of all instances of annotation_occurrence.

Formal propositions

WR1: Each instance of annotation_occurrence shall be of type annotation_curve_occurrence, annotation_fill_area_occurrence,annotation_symbol_occurrence, annotation_text_occurrence, and/or draughting_annotation_occurrence.

5.2.4.253 subtype_mandatory_camera_image

The subtype_mandatory_camera_image rule ensures that all camera_image entities are of type camera_image_2d_with_scale or camera_image_3d_with_scale.
*)
RULE subtype_mandatory_camera_image FOR
    (camera_image);
WHERE
  WR1:  SIZEOF(QUERY (ci <* camera_image |
                    NOT (type_check_function(ci,
                        ['AUTOMOTIVE_DESIGN.CAMERA_IMAGE_2D_WITH_SCALE',
                         'AUTOMOTIVE_DESIGN.CAMERA_IMAGE_3D_WITH_SCALE'] , 0)
                      ))) = 0;
END_RULE;
(*

Argument definitions:

camera_image: the set of all instances of camera_image.

Formal propositions

WR1: Each camera_image shall be either a camera_image_2d_with_scale or a camera_image_3d_with_scale.

5.2.4.254 subtype_mandatory_camera_model

The subtype_mandatory_camera_model rule ensures that all camera_model entities are of type camera_model_d2 or camera_model_d3.
*)
RULE subtype_mandatory_camera_model FOR
    (camera_model);
WHERE
  WR1:  SIZEOF(QUERY (cm <* camera_model |
                        NOT (type_check_function(cm,
                        ['AUTOMOTIVE_DESIGN.CAMERA_MODEL_D2',
                        'AUTOMOTIVE_DESIGN.CAMERA_MODEL_D3'] , 0)
                            ))) = 0;
END_RULE;
(*

Argument definitions:

camera_model: the set of all instances of camera_model.

Formal propositions

WR1: Each camera_model shall be either a camera_model_d2 or a camera_model_d3.

5.2.4.255 subtype_mandatory_colour_specification

The subtype_mandatory_colour_specification rule ensures that all colour_specification entities are of type colour_rgb.
*)
RULE subtype_mandatory_colour_specification FOR
    (colour_specification);
WHERE
  WR1:  SIZEOF(QUERY (cs <* colour_specification |
                        NOT (type_check_function(cs,
                        ['AUTOMOTIVE_DESIGN.COLOUR_RGB'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

colour_specification: the set of all instances of colour_specification.

Formal propositions

WR1: Each colour_specification shall be of type colour_rgb.

5.2.4.256 subtype_mandatory_configurable_item

The subtype_mandatory_configurable_item rule ensures that all configurable_item entities are of type product_specification.
*)
RULE subtype_mandatory_configurable_item FOR
    (configurable_item);
WHERE
  WR1:  SIZEOF(QUERY (ci <* configurable_item |
                        NOT (type_check_function(ci,
                        ['AUTOMOTIVE_DESIGN.PRODUCT_SPECIFICATION'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

configurable_item: the set of all instances of configurable_item.

Formal propositions

WR1: Each configurable_item shall be of type product_specification.

5.2.4.257 subtype_mandatory_document_product_association

The subtype_mandatory_document_product_association rule ensures that all document_product_association entities are of type document_product_equivalence.
*)
RULE subtype_mandatory_document_product_association FOR
    (document_product_association);
WHERE
  WR1:  SIZEOF(QUERY (dpa <* document_product_association |
                        NOT (type_check_function(dpa,
                        ['AUTOMOTIVE_DESIGN.DOCUMENT_PRODUCT_EQUIVALENCE'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

document_product_association: the set of all instances of document_product_association.

Formal propositions

WR1: Each document_product_association shall be of type document_product_equivalence.

5.2.4.258 subtype_mandatory_draughting_callout

The subtype_mandatory_draughting_callout rule ensures that all draughting_callout entities are of type datum_feature_callout, datum_target_callout, dimension_curve_directed_callout, draughting_elements, geometrical_tolerance_callout, leader_directed_callout, projection_directed_callout, structured_dimension_callout, and/or surface_condition_callout.
*)
RULE subtype_mandatory_draughting_callout FOR
    (draughting_callout);
WHERE
  WR1:  SIZEOF(QUERY (dc <* draughting_callout |
                        NOT (type_check_function(dc,
                        ['AUTOMOTIVE_DESIGN.DATUM_FEATURE_CALLOUT',
                        'AUTOMOTIVE_DESIGN.DATUM_TARGET_CALLOUT',
                        'AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT',
                        'AUTOMOTIVE_DESIGN.DRAUGHTING_ELEMENTS',
                        'AUTOMOTIVE_DESIGN.GEOMETRICAL_TOLERANCE_CALLOUT',
                        'AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT',
                        'AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT',
                        'AUTOMOTIVE_DESIGN.STRUCTURED_DIMENSION_CALLOUT',
                        'AUTOMOTIVE_DESIGN.SURFACE_CONDITION_CALLOUT'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

draughting_callout: the set of all instances of draughting_callout.

Formal propositions

WR1: Each draughting_callout shall be of type datum_feature_callout, datum_target_callout, dimension_curve_directed_callout, draughting_elements, geometrical_tolerance_callout, leader_directed_callout, projection_directed_callout, structured_dimension_callout, and/or surface_condition_callout.

5.2.4.259 subtype_mandatory_externally_defined_item

The subtype_mandatory_externally_defined_item rule ensures that all externally_defined_item entities are of type externally_defined_character_glyph, externally_defined_class, externally_defined_curve_font, externally_defined_feature_definition, externally_defined_general_property, externally_defined_hatch_style, externally_defined_style, externally_defined_symbol, externally_defined_text_font, or externally_defined_tile_style.
*)
RULE subtype_mandatory_externally_defined_item FOR
    (externally_defined_item);
WHERE
  WR1:  SIZEOF(QUERY (edi <* externally_defined_item |
                        NOT (type_check_function(edi,
                        ['AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CHARACTER_GLYPH',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CURVE_FONT',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_FEATURE_DEFINITION',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_GENERAL_PROPERTY',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_HATCH_STYLE',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_STYLE',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_SYMBOL',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_TEXT_FONT',
                        'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_TILE_STYLE'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

externally_defined_item: the set of all instances of externally_defined_item.

Formal propositions

WR1: Each externally_defined_item shall be either a externally_defined_character_glyph, externally_defined_class, externally_defined_curve_font, externally_defined_feature_definition, externally_defined_general_property, externally_defined_hatch_style, externally_defined_style, externally_defined_symbol, externally_defined_text_font, or externally_defined_tile_style.

5.2.4.260 subtype_mandatory_founded_item

The subtype_mandatory_founded_item rule ensures that all founded_item entities are of type composite_curve_segment, surface_patch, or view_volume.
*)
RULE subtype_mandatory_founded_item FOR
    (founded_item);
WHERE
  WR1:  SIZEOF(QUERY (fi <* founded_item |
                        NOT (type_check_function(fi,
                        ['AUTOMOTIVE_DESIGN.COMPOSITE_CURVE_SEGMENT',
                        'AUTOMOTIVE_DESIGN.SURFACE_PATCH',
                        'AUTOMOTIVE_DESIGN.VIEW_VOLUME'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

founded_item: the set of all instances of founded_item.

Formal propositions

WR1: Each founded_item shall be of type composite_curve_segment, surface_patch, or view_volume.

5.2.4.261 subtype_mandatory_geometric_tolerance

The subtype_mandatory_geometric_tolerance rule ensures that each geometric_tolerance is a angularity_tolerance, circular_runout_tolerance, concentricity_tolerance, cylindricity_tolerance, flatness_tolerance, line_profile_tolerance, parallelism_tolerance, perpendicularity_tolerance, position_tolerance, roundness_tolerance, straightness_tolerance, surface_profile_tolerance, symmetry_tolerance, or total_runout_tolerance.
*)
RULE subtype_mandatory_geometric_tolerance FOR
    (geometric_tolerance);
WHERE
  WR1:  SIZEOF(QUERY ( gt <* geometric_tolerance | 
                        NOT (type_check_function(gt,
                       ['AUTOMOTIVE_DESIGN.ANGULARITY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.CIRCULAR_RUNOUT_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.COAXIALITY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.CONCENTRICITY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.CYLINDRICITY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.FLATNESS_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.LINE_PROFILE_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.PARALLELISM_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.PERPENDICULARITY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.POSITION_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.ROUNDNESS_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.STRAIGHTNESS_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.SURFACE_PROFILE_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.SYMMETRY_TOLERANCE',
                        'AUTOMOTIVE_DESIGN.TOTAL_RUNOUT_TOLERANCE'] , 0)
                    ))) = 0;
        
         
END_RULE;
(*

Argument definitions:

geometric_tolerance: the set of all instances of geometric_tolerance.

Formal propositions

WR1: Each instance of geometric_tolerance shall be of type angularity_tolerance, circular_runout_tolerance, coaxiality_tolerance, concentricity_tolerance, cylindricity_tolerance, flatness_tolerance, line_profile_tolerance, parallelism_tolerance, perpendicularity_tolerance, position_tolerance, roundness_tolerance, straightness_tolerance, surface_profile_tolerance, symmetry_tolerance, or total_runout_tolerance.

5.2.4.262 subtype_mandatory_pre_defined_colour

The subtype_mandatory_pre_defined_colour rule ensures that all pre_defined_colour entities are of type draughting_pre_defined_colour.
*)
RULE subtype_mandatory_pre_defined_colour FOR
    (pre_defined_colour);
WHERE
  WR1:  SIZEOF(QUERY (pdc <* pre_defined_colour |
                        NOT (type_check_function(pdc,
                        ['AUTOMOTIVE_DESIGN.DRAUGHTING_PRE_DEFINED_COLOUR'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_colour: the set of all instances of pre_defined_colour.

Formal propositions

WR1: Each pre_defined_colour shall be a draughting_pre_defined_colour.

5.2.4.263 subtype_mandatory_pre_defined_curve_font

The subtype_mandatory_pre_defined_curve_font rule ensures that all pre_defined_curve_font entities are of type draughting_pre_defined_curve_font.
*)
RULE subtype_mandatory_pre_defined_curve_font FOR
    (pre_defined_curve_font);
WHERE
  WR1:  SIZEOF(QUERY (pdcf <* pre_defined_curve_font |
                        NOT (type_check_function(pdcf,
                        ['AUTOMOTIVE_DESIGN.DRAUGHTING_PRE_DEFINED_CURVE_FONT'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_curve_font: the set of all instances of pre_defined_curve_font.

Formal propositions

WR1: Each pre_defined_curve_font shall be a draughting_pre_defined_curve_font.

5.2.4.264 subtype_mandatory_pre_defined_item

The subtype_mandatory_pre_defined_item rule ensures that all pre_defined_item entities are of type known_source, pre_defined_colour, pre_defined_curve_font, pre_defined_marker, pre_defined_presentation_style, pre_defined_symbol, or pre_defined_text_font.
*)
RULE subtype_mandatory_pre_defined_item FOR
    (pre_defined_item);
WHERE
  WR1:  SIZEOF(QUERY (pdi <* pre_defined_item |
                        NOT (type_check_function(pdi,
                        ['AUTOMOTIVE_DESIGN.KNOWN_SOURCE',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_COLOUR',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_CURVE_FONT',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_MARKER',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_PRESENTATION_STYLE',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_SYMBOL',
                        'AUTOMOTIVE_DESIGN.PRE_DEFINED_TEXT_FONT'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_item: the set of all instances of pre_defined_item.

Formal propositions

WR1: Each pre_defined_item shall be of type known_source, pre_defined_colour, pre_defined_curve_font, pre_defined_marker, pre_defined_presentation_style, pre_defined_symbol, or pre_defined_text_font.

5.2.4.265 subtype_mandatory_pre_defined_symbol

The subtype_mandatory_pre_defined_symbol rule ensures that all pre_defined_symbol entities are of type pre_defined_geometrical_tolerance_symbol, pre_defined_dimension_symbol, pre_defined_point_marker_symbol, pre_defined_surface_condition_symbol, or pre_defined_terminator_symbol.
*)
RULE subtype_mandatory_pre_defined_symbol FOR
    (pre_defined_symbol);
WHERE
  WR1:  SIZEOF(QUERY (pds <* pre_defined_symbol |
                        NOT (type_check_function(pds,
                        ['AUTOMOTIVE_DESIGN.PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL',
                         'AUTOMOTIVE_DESIGN.PRE_DEFINED_SURFACE_CONDITION_SYMBOL',
                         'AUTOMOTIVE_DESIGN.PRE_DEFINED_DIMENSION_SYMBOL',
                         'AUTOMOTIVE_DESIGN.PRE_DEFINED_POINT_MARKER_SYMBOL',
                         'AUTOMOTIVE_DESIGN.PRE_DEFINED_TERMINATOR_SYMBOL'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_symbol: the set of all instances of pre_defined_symbol.

Formal propositions

WR1: Each pre_defined_symbol shall be of type pre_defined_geometrical_tolerance_symbol, pre_defined_surface_condition_symbol, pre_defined_dimension_symbol, pre_defined_point_marker_symbol, or pre_defined_terminator_symbol.

5.2.4.266 subtype_mandatory_pre_defined_text_font

The subtype_mandatory_pre_defined_text_font rule ensures that all pre_defined_text_font entities are of type draughting_pre_defined_text_font.

*)
RULE subtype_mandatory_pre_defined_text_font FOR
    (pre_defined_text_font);
WHERE
  WR1:  SIZEOF(QUERY (pdtf <* pre_defined_text_font |
                        NOT (type_check_function(pdtf,
                        ['AUTOMOTIVE_DESIGN.DRAUGHTING_PRE_DEFINED_TEXT_FONT'] , 0)
                  ))) = 0;
END_RULE;
(*

Argument definitions:

pre_defined_text_font: the set of all instances of pre_defined_text_font.

Formal Propositions:

WR1: Each pre_defined_text_font shall be a draughting_pre_defined_text_font.

5.2.4.267 terminator_symbol_constraint

The terminator_symbol_constraint rule ensures that a defined_symbol that is used as the definition of a terminator_symbol is described by a pre_defined_terminator_symbol.
*)
RULE terminator_symbol_constraint FOR
    (terminator_symbol);
WHERE
  WR1:  SIZEOF (QUERY (ts <* terminator_symbol |
                 (('AUTOMOTIVE_DESIGN.DEFINED_SYMBOL' IN TYPEOF(ts.item))
                 AND
                 NOT ('AUTOMOTIVE_DESIGN.PRE_DEFINED_TERMINATOR_SYMBOL' IN
                         TYPEOF (ts.item\defined_symbol.definition)))
               )) = 0;   
END_RULE;
(*

Argument definitions:

terminator_symbol: the set of all instances of terminator_symbol.

Formal propositions

WR1: Each terminator_symbol that has an implicit definition shall be defined by a pre_defined_terminator_symbol.

5.2.4.268 text_font_usage

The text_font_usage rule ensures that every pre_defined_text_font and externally_defined_text_font is used in the presentation of a text_literal.
*)
RULE text_font_usage FOR
    (externally_defined_text_font,
     pre_defined_text_font);
WHERE
  WR1:  SIZEOF (QUERY (pdtf <* pre_defined_text_font |
               SIZEOF (USEDIN (pdtf, 'AUTOMOTIVE_DESIGN.TEXT_LITERAL.FONT')
                ) = 0
              )) = 0;
           
  WR2:  SIZEOF (QUERY (edtf <* externally_defined_text_font |
               SIZEOF (USEDIN (edtf, 'AUTOMOTIVE_DESIGN.TEXT_LITERAL.FONT')
                ) = 0
              )) = 0;
           
END_RULE;
(*

Argument definitions:

externally_defined_text_font: the set of all instances of externally_defined_text_font.

pre_defined_text_font: the set of all instances of pre_defined_text_font.

pre_defined_text_font: the set of all instances of pre_defined_text_font.

Formal propositions

WR1: Each pre_defined_text_font shall be the font for at least one text_literal.

WR2: Each externally_defined_text_font shall be the font for at least one text_literal.

5.2.4.269 versioned_action_request_requires_date_and_person_or_organization

The versioned_action_request_requires_date_and_person_or_organization rule specifies that each instance of versioned_action_request shall be referenced by at least two instances of either applied_person_and_organization_assignment or applied_organization_assignment that has a role with a name of 'requestor' and 'notified person or organization', respectively. This rule enforces the requirement for every Work_request to have at least one notified person or organization associated to it.
*)
RULE versioned_action_request_requires_date_and_person_or_organization FOR
    (versioned_action_request);
WHERE
  WR1:  SIZEOF( QUERY( va <* versioned_action_request |
               (SIZEOF( QUERY( adapaoa <* USEDIN( va,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT.ITEMS') |
                  adapaoa.role.name = 'requestor' )) +
                SIZEOF( QUERY( adaoa <* USEDIN( va,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS') |
                   adaoa.role.name = 'requestor' )) 
                 ) = 0
               )) = 0;
           
  WR2:  SIZEOF( QUERY( va <* versioned_action_request |
               (SIZEOF( QUERY( adapaoa <* USEDIN( va,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT.ITEMS') |
                  adapaoa.role.name = 'notified person or organization' )) +
                SIZEOF( QUERY( adaoa <* USEDIN( va,'AUTOMOTIVE_DESIGN.' +
                        'APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS') |
                   adaoa.role.name = 'notified person or organization' )) 
                 ) = 0
               )) = 0;
           
END_RULE;
(*

Argument definitions:

versioned_action_request: the set of all instances of versioned_action_request.

Formal propositions

WR1: For each instance of versioned_action_request there shall be at least one instance of either applied_person_and_organization_assignment, or applied_organization_assignment that contains the instance of versioned_action_request in its set of items and has a role with a name of 'requestor'.

WR2: For each instance of versioned_action_request there shall be at least one instance of either applied_person_and_organization_assignment, or applied_organization_assignment that contains the instance of versioned_action_request in its set of items and has a role with a name of 'notified person or organization'.

5.2.4.270 versioned_action_request_requires_status

The versioned_action_request_requires_status rule specifies that each instance of versioned_action_request shall have exactly one status. The status of a versioned_action_request is defined by the action_request_status entity.
*)
RULE versioned_action_request_requires_status FOR
    (action_request_status,
     versioned_action_request);
WHERE
  WR1:  SIZEOF( QUERY( ar <* versioned_action_request |
          NOT( SIZEOF( QUERY( ars <* action_request_status |
            ar :=: ars.assigned_request)) = 1 )
          )) = 0;
           
END_RULE;
(*

Argument definitions:

action_request_status: the set of all instances of action_request_status.

versioned_action_request: the set of all instances of versioned_action_request.

versioned_action_request: the set of all instances of versioned_action_request.

Formal propositions

WR1: For each instance of versioned_action_request there shall be exactly one instance of action_request_status that contains an assigned_request attribute value to this instance of versioned_action_request.

5.2.4.271 restrict_representation_for_surface_condition

The restrict_representation_for_surface_condition rule enforces that the instance of representation that provides the values of a particular kind of surface condition be associated with the appropriate instance of property_definition.
*)
RULE restrict_representation_for_surface_condition FOR
	(property_definition_representation);
WHERE
 WR1: SIZEOF(QUERY('AUTOMOTIVE_DESIGN.'+'PROPERTY_DEFINITION' IN TYPEOF
          (pdr.definition)) AND (pdr <* property_definition_representation |
	  NOT surface_condition_correlation(pdr.definition,
	  pdr.used_representation
	  )))=0;
END_RULE;
(*

Argument definitions:

property_definition_representation: the set of all instances of property_definition_representation.

Formal Propositions:

WR1: There shall not be any instance of property_definition_representation such that the represented property identifies a particular kind of surface condition and such the used_representation is not representation appropriate for this kind of surface_condition.

NOTE In this version of the application protocol, property-representation  correlation is only assessed comparing the names of the property_definition and of the representation.



© ISO 2010 — All rights reserved