module untitledModel
 sig RuleBase{
vocabulary:lone Vocabulary, 
ruleset:set RuleSet, 
externalvocabulary:set ExternalVocabulary}
 sig Vocabulary{
vocabularyentery:some VocabularyEntery}
 sig RuleSet{
rulebase:one RuleBase, 
variable:set Variable, 
vocabulary:lone Vocabulary, 
externalvocabulary:one ExternalVocabulary}
 sig ExternalVocabulary{
}
 sig ExternalVocabularyLanguage{
}
 sig Variable{
ruleset:set RuleSet, 
objectvariable:lone ObjectVariable, 
genericvariable:lone GenericVariable, 
datavariable:one DataVariable}
 sig IntegrityRuleSet extends RuleSet{
integrityrule:set IntegrityRule}
 sig DerivationRuleSet extends RuleSet{
derivationrule:set DerivationRule}
 sig ReactionRuleSet extends RuleSet{
reactionrule:set ReactionRule}
 sig ProductionRuleSet extends RuleSet{
productionrule:set ProductionRule}
 sig ReactionRule{
andornafnegformula:some AndOrNafNegFormula, 
andornafnegformula:set AndOrNafNegFormula, 
eventexpression:one EventExpression, 
eventexpression:one EventExpression}
 sig ProductionRule{
andornafnegformula:some AndOrNafNegFormula, 
programactionexpression:some ProgramActionExpression, 
andornafnegformula:set AndOrNafNegFormula}
 sig DerivationRule{
andornafnegformula:some AndOrNafNegFormula, 
literalconjunction:one LiteralConjunction, 
objectdescriptionatom:one ObjectDescriptionAtom, 
logicalformula:one LogicalFormula}
 sig IntegrityRule{
logicalformula:one LogicalFormula}
 sig AlethicIntegrityRule extends IntegrityRule{
}
 sig DeonticIntegrityRule extends IntegrityRule{
}
 sig LogicalFormula{
implication:one Implication, 
derivationrule:one DerivationRule}
 sig AndOrNafNegFormula{
disjunction:lone Disjunction, 
conjunction:lone Conjunction, 
atom:lone Atom}
 sig LiteralConjunction{
atom:some Atom}
 sig ProgramActionExpression extends AtomicEventExpression{
}
 sig EventExpression{
obligationordispensation:one ObligationOrDispensation}
 sig Conjunction extends LogicalFormula{
logicalformula:set LogicalFormula, 
andornafnegformula:set AndOrNafNegFormula, 
andornafnegformula:one AndOrNafNegFormula}
 sig Disjunction extends LogicalFormula{
logicalformula:one LogicalFormula, 
andornafnegformula:set AndOrNafNegFormula, 
andornafnegformula:one AndOrNafNegFormula}
 sig NegationAsFailure extends LogicalFormula{
logicalformula:one LogicalFormula, 
negation:one Negation}
 sig StrongNegation extends LogicalFormula{
logicalformula:one LogicalFormula, 
negation:one Negation}
 sig Implication extends LogicalFormula{
logicalformula:one LogicalFormula, 
logicalformula:one LogicalFormula}
 sig Atom extends LogicalFormula{
andornafnegformula:one AndOrNafNegFormula}
 sig QuantifiedFormula extends LogicalFormula{
logicalformula:one LogicalFormula, 
variable:one Variable}
 sig ExistentiallyQuantifiedFormula extends QuantifiedFormula{
}
 sig AtleastQuantifiedFormula extends QuantifiedFormula{
atleastandatmostquantifiedformula:lone AtLeastAndAtMostQuantifiedFormula}
 sig AtMostQuantifiedFormula extends QuantifiedFormula{
}
 sig UniversallyQuantifiedFormula extends QuantifiedFormula{
}
 sig AtLeastAndAtMostQuantifiedFormula extends AtleastQuantifiedFormula{
atleastquantifiedformula:one AtleastQuantifiedFormula}
 sig Negation extends AndOrNafNegFormula{
andornafnegformula:one AndOrNafNegFormula, 
strongnegation:lone StrongNegation, 
negationasfailure:lone NegationAsFailure}
 sig ObjectAtom extends Atom{
}
 sig DataAtom extends Atom{
}
 sig GenericAtom extends Atom{
genericpredicate:one GenericPredicate, 
term:set Term}
 sig ObjectClassificationAtom extends ObjectAtom{
class:one Class, 
objectterm:one ObjectTerm, 
actor:one Actor, 
action:one Action}
 sig ObjectDescriptionAtom extends ObjectAtom{
class:lone Class, 
class:set Class, 
objectterm:one ObjectTerm, 
slot:some Slot, 
policy:one Policy, 
derivationrule:one DerivationRule}
 sig AssociationAtom extends ObjectAtom{
objectterm:set ObjectTerm, 
dataterm:set DataTerm, 
associationpredicate:one AssociationPredicate}
 sig PropertyAtom extends ObjectAtom{
referencepropertyatom:lone ReferencePropertyAtom}
 sig AttributionAtom extends PropertyAtom{
dataterm:one DataTerm, 
objectterm:one ObjectTerm, 
objectterm:one ObjectTerm, 
attribute:one Attribute}
 sig ReferencePropertyAtom extends Property{
objectterm:one ObjectTerm, 
objectterm:one ObjectTerm, 
referenceproperty:some ReferenceProperty, 
propertyatom:one PropertyAtom}
 sig EqualityAtom extends ObjectAtom{
objectterm:set ObjectTerm}
 sig InequalityAtom extends ObjectAtom{
objectterm:set ObjectTerm}
 sig DatatypePredicateAtom extends DataAtom{
dataterm:some DataTerm, 
datatypepredicate:one DatatypePredicate}
 sig DataClassificationAtom extends DataAtom{
dataterm:one DataTerm, 
datatype:one DataType}
 sig Class extends Type{
objectclassificationatom:set ObjectClassificationAtom, 
objectdescriptionatom:one ObjectDescriptionAtom, 
objectdescriptionatom:one ObjectDescriptionAtom, 
objectvariable:set ObjectVariable, 
objectname:set ObjectName, 
retractactionexpression:set RetractActionExpression, 
assertactionexpression:set AssertActionExpression, 
property:set Property, 
operation:set Operation, 
objectoperation:set ObjectOperation}
 sig ObjectTerm extends Term{
attributionatom:one AttributionAtom, 
atomiceventexpression:one AtomicEventExpression}
 sig DataTerm extends Term{
}
 sig DataType extends Type{
dataclassificationatom:set DataClassificationAtom, 
datavariable:set DataVariable, 
typedliteral:set TypedLiteral, 
dataoperation:set DataOperation}
 sig ReferenceProperty{
referencepropertyatom:one ReferencePropertyAtom, 
objectslot:set ObjectSlot, 
referencepropertyfunctionterm:set ReferencePropertyFunctionTerm}
 sig Attribute extends Property{
attributionatom:set AttributionAtom, 
dataslot:set DataSlot, 
attributefunctionterm:one AttributeFunctionTerm}
 sig ObjectSlot extends Slot{
referenceproperty:one ReferenceProperty, 
objectterm:one ObjectTerm}
 sig Slot{
assertactionexpression:one AssertActionExpression}
 sig DataSlot extends Slot{
dataterm:one DataTerm, 
attribute:one Attribute}
 sig GenericPredicate extends Predicate{
genericatom:set GenericAtom, 
predicatetypeenumerationliteral:lone PredicateTypeEnumerationLiteral, 
type:set Type}
 sig Term{
}
 sig PredicateTypeEnumerationLiteral{
}
 sig AssociationPredicate extends Predicate{
associationatom:set AssociationAtom, 
type:set Type}
 sig DatatypePredicate extends Predicate{
datatypepredicateatom:set DatatypePredicateAtom, 
type:some Type}
 sig GenericTerm extends Term{
}
 sig DataVariable{
datatype:lone DataType, 
variable:one Variable}
 sig GenericVariable{
type:lone Type, 
variable:one Variable}
 sig ObjectVariable{
class:lone Class, 
variable:one Variable}
 sig ObjectName{
class:one Class, 
vocabularyentery:one VocabularyEntery}
 sig ObjectOperationTerm extends ObjectTerm{
objectterm:lone ObjectTerm, 
term:set Term, 
objectoperation:one ObjectOperation}
 sig ObjectOperation extends Operation{
objectoperationterm:set ObjectOperationTerm, 
class:one Class}
 sig ReferencePropertyFunctionTerm extends ObjectTerm{
objectterm:one ObjectTerm, 
referenceproperty:one ReferenceProperty}
 sig DataLiteral extends DataTerm{
enumerationdatatype:one EnumerationDatatype}
 sig DataFunctionTerm extends DataTerm{
}
 sig TypedLiteral extends DataLiteral{
datatype:one DataType}
 sig PlainLiteral extends DataLiteral{
}
 sig DataOperationTerm extends DataFunctionTerm{
objectterm:one ObjectTerm, 
term:some Term, 
dataoperation:one DataOperation}
 sig AttributeFunctionTerm extends DataFunctionTerm{
objectterm:one ObjectTerm, 
attribute:one Attribute}
 sig DataOperation extends Operation{
dataoperationterm:set DataOperationTerm, 
datatype:one DataType}
 sig DataTypeFuncionTerm extends DataFunctionTerm{
datatypefunction:one DataTypeFunction, 
dataterm:some DataTerm}
 sig DataTypeFunction extends Function{
datatypefuncionterm:set DataTypeFuncionTerm, 
type:set Type}
 sig Type extends VocabularyEntry{
genericentityname:set GenericEntityName, 
genericvariable:set GenericVariable, 
associationpredicate:set AssociationPredicate, 
genericpredicate:set GenericPredicate, 
datatypepredicate:set DatatypePredicate, 
property:set Property, 
genericfunction:set GenericFunction, 
datatypefunction:set DataTypeFunction}
 sig GenericEntityName{
type:lone Type, 
vocabularyentery:one VocabularyEntery}
 sig GenericFunctionTerm extends GenericTerm{
genericfunction:one GenericFunction, 
genericterm:one GenericTerm}
 sig GenericFunction extends Function{
genericfunctionterm:one GenericFunctionTerm, 
type:set Type}
 sig AndNotEventExpression{
eventexpression:set EventExpression}
 sig SequenceEventExpression extends EventExpression{
eventexpression:set EventExpression}
 sig EventType{
atomiceventexpression:one AtomicEventExpression}
 sig AtomicEventExpression extends EventExpression{
eventtype:set EventType, 
objectterm:one ObjectTerm, 
slot:one Slot}
 sig ParallelEventExpression extends EventExpression{
eventexpression:set EventExpression}
 sig ChoiceEventExpression extends EventExpression{
eventexpression:some EventExpression}
 sig UpdateActionExpr extends UpdateStateActionExpr{
term:one Term, 
property:one Property, 
objectterm:one ObjectTerm}
 sig InvokeActionExpression extends ProgramActionExpression{
operation:set Operation, 
term:one Term, 
objectterm:lone ObjectTerm}
 sig Operation extends Function{
invokeactionexpression:one InvokeActionExpression, 
class:lone Class}
 sig Property extends VocabularyEntry{
updateactionexpr:set UpdateActionExpr, 
type:lone Type, 
class:lone Class, 
predicate:one Predicate}
 sig UpdateStateActionExpr extends ProgramActionExpression{
}
 sig AssertActionExpression extends UpdateStateActionExpr{
objectterm:one ObjectTerm, 
class:one Class, 
slot:set Slot}
 sig RetractActionExpression extends UpdateStateActionExpr{
objectterm:one ObjectTerm, 
class:one Class}
 sig PeriodicTimeEventType extends TimeEventType{
}
 sig EveryMinuteTimeEventType extends PeriodicTimeEventType{
}
 sig EveryDayTimeEventType extends PeriodicTimeEventType{
}
 sig EveryMonthTimeEventType extends PeriodicTimeEventType{
}
 sig EveryHourTimeEventType extends PeriodicTimeEventType{
}
 sig EveryWeekTimeEventType extends PeriodicTimeEventType{
}
 sig EveryYearTimeEventType extends PeriodicTimeEventType{
}
 sig AtomicEventType extends EventType{
}
 sig TimeEventType extends AtomicEventType{
}
 sig AtomicActionEventType extends AtomicEventType{
}
 sig SingularTimeEventType extends TimeEventType{
}
 sig PeriodicTimeEventType{
}
 sig MessageType extends AtomicActionEventType{
messagetypetype:one MessageTypeType}
 sig SOAPMessageType extends MessageType{
}
 sig SOAP-RPC-RequestMsgType extends MessageType{
}
 sig SOAP-RPC-ResponseMsgType extends MessageType{
}
 sig SOAP-RPC-ConservativeMsgType extends MessageType{
}
 sig MessageTypeType extends AtomicActionEventType{
messagetype:set MessageType}
 sig Predicate extends VocabularyEntry{
property:lone Property}
 sig DatatypePredicate{
}
 sig Function extends VocabularyEntry{
}
 sig VocabularyEntery{
vocabulary:one Vocabulary, 
objectname:lone ObjectName, 
genericentityname:lone GenericEntityName}
 sig EnumerationDatatype extends Datatype{
dataliteral:set DataLiteral}
 sig Actor extends Entity{
objectclassificationatom:one ObjectClassificationAtom}
 sig Action extends ActionExpression{
objectclassificationatom:one ObjectClassificationAtom, 
policy:one Policy, 
policy:set Policy, 
obligationordispensation:one ObligationOrDispensation, 
entity:one Entity, 
entity:one Entity, 
entity:one Entity}
 sig ActionExpression{
}
 sig Entity{
action:one Action, 
action:one Action, 
action:one Action}
 sig Policy extends Entity{
action:one Action, 
action:one Action, 
objectdescriptionatom:one ObjectDescriptionAtom, 
content:one Content}
 sig ObligationOrDispensation extends Policy{
action:one Action, 
eventexpression:one EventExpression}
 sig Dispensation extends ObligationOrDispensation{
}
 sig Obligation ObligationOrDispensation{
}
 sig Prohibition extends Policy{
}
 sig Permission extends Policy{
}
 sig Content extends Entity{
policy:one Policy}
fact Vocabulary_voca1_fact { Vocabulary_voca1[  ] }
fact Vocabulary_voca2_fact { Vocabulary_voca2[  ] }
fact Vocabulary_voca21_fact { Vocabulary_voca21[  ] }
fact Vocabulary_voca22_fact { Vocabulary_voca22[  ] }
fact RuleSet_rule1_fact { RuleSet_rule1[  ] }
fact RuleSet_rule2_fact { RuleSet_rule2[  ] }
fact ReactionRule_reac1_fact { ReactionRule_reac1[  ] }
fact ReactionRule_reac2_fact { ReactionRule_reac2[  ] }
fact ProductionRule_prod1_fact { ProductionRule_prod1[  ] }
fact ProductionRule_prod2_fact { ProductionRule_prod2[  ] }
fact DerivationRule_deriv1_fact { DerivationRule_deriv1[  ] }
fact DerivationRule_deriv2_fact { DerivationRule_deriv2[  ] }
fact IntegrityRule_integ1_fact { IntegrityRule_integ1[  ] }
fact IntegrityRule_integ2_fact { IntegrityRule_integ2[  ] }
fact LogicalFormula_logi1_fact { LogicalFormula_logi1[  ] }
fact LogicalFormula_logi2_fact { LogicalFormula_logi2[  ] }
fact LogicalFormula_logi21_fact { LogicalFormula_logi21[  ] }
fact LogicalFormula_logi22_fact { LogicalFormula_logi22[  ] }
fact LogicalFormula_logi31_fact { LogicalFormula_logi31[  ] }
fact LogicalFormula_logi32_fact { LogicalFormula_logi32[  ] }
fact LogicalFormula_logi41_fact { LogicalFormula_logi41[  ] }
fact LogicalFormula_logi42_fact { LogicalFormula_logi42[  ] }
fact LogicalFormula_logi51_fact { LogicalFormula_logi51[  ] }
fact LogicalFormula_logi52_fact { LogicalFormula_logi52[  ] }
fact LogicalFormula_logi61_fact { LogicalFormula_logi61[  ] }
fact LogicalFormula_logi62_fact { LogicalFormula_logi62[  ] }
fact LogicalFormula_logi71_fact { LogicalFormula_logi71[  ] }
fact LogicalFormula_logi72_fact { LogicalFormula_logi72[  ] }
fact AndOrNafNegFormula_andor1_fact { AndOrNafNegFormula_andor1[  ] }
fact AndOrNafNegFormula_andor2_fact { AndOrNafNegFormula_andor2[  ] }
fact AndOrNafNegFormula_andor11_fact { AndOrNafNegFormula_andor11[  ] }
fact AndOrNafNegFormula_andor12_fact { AndOrNafNegFormula_andor12[  ] }
fact AndOrNafNegFormula_andor21_fact { AndOrNafNegFormula_andor21[  ] }
fact AndOrNafNegFormula_andor22_fact { AndOrNafNegFormula_andor22[  ] }
fact AndOrNafNegFormula_andor31_fact { AndOrNafNegFormula_andor31[  ] }
fact AndOrNafNegFormula_andor32_fact { AndOrNafNegFormula_andor32[  ] }
fact AndOrNafNegFormula_andor41_fact { AndOrNafNegFormula_andor41[  ] }
fact AndOrNafNegFormula_andor42_fact { AndOrNafNegFormula_andor42[  ] }
fact EventExpression_even1_fact { EventExpression_even1[  ] }
fact EventExpression_even2_fact { EventExpression_even2[  ] }
fact EventExpression_even21_fact { EventExpression_even21[  ] }
fact EventExpression_even22_fact { EventExpression_even22[  ] }
fact EventExpression_even31_fact { EventExpression_even31[  ] }
fact EventExpression_even32_fact { EventExpression_even32[  ] }
fact EventExpression_even41_fact { EventExpression_even41[  ] }
fact EventExpression_even42_fact { EventExpression_even42[  ] }
fact EventExpression_event51_fact { EventExpression_event51[  ] }
fact EventExpression_event52_fact { EventExpression_event52[  ] }
fact Conjunction_conjg1_fact { Conjunction_conjg1[  ] }
fact Disjunction_disjg1_fact { Disjunction_disjg1[  ] }
fact NegationAsFailure_negag1_fact { NegationAsFailure_negag1[  ] }
fact StrongNegation_strog1_fact { StrongNegation_strog1[  ] }
fact Atom_atom1_fact { Atom_atom1[  ] }
fact Atom_atom2_fact { Atom_atom2[  ] }
fact Atom_atomg1_fact { Atom_atomg1[  ] }
fact AtLeastAndAtMostQuantifiedFormula_newConstraint_fact { AtLeastAndAtMostQuantifiedFormula_newConstraint[  ] }
fact ReferencePropertyAtom_refeg1_fact { ReferencePropertyAtom_refeg1[  ] }
fact ObjectTerm_obje1_fact { ObjectTerm_obje1[  ] }
fact ObjectTerm_obje2_fact { ObjectTerm_obje2[  ] }
fact ObjectTerm_obje21_fact { ObjectTerm_obje21[  ] }
fact ObjectTerm_obje22_fact { ObjectTerm_obje22[  ] }
fact ObjectTerm_obje31_fact { ObjectTerm_obje31[  ] }
fact ObjectTerm_obje32_fact { ObjectTerm_obje32[  ] }
fact ObjectTerm_obje41_fact { ObjectTerm_obje41[  ] }
fact ObjectTerm_obje42_fact { ObjectTerm_obje42[  ] }
fact ObjectTerm_obje51_fact { ObjectTerm_obje51[  ] }
fact ObjectTerm_obje52_fact { ObjectTerm_obje52[  ] }
fact ObjectTerm_obje61_fact { ObjectTerm_obje61[  ] }
fact ObjectTerm_obje62_fact { ObjectTerm_obje62[  ] }
fact ObjectTerm_obje71_fact { ObjectTerm_obje71[  ] }
fact ObjectTerm_obje81_fact { ObjectTerm_obje81[  ] }
fact ObjectTerm_obje72_fact { ObjectTerm_obje72[  ] }
fact ObjectTerm_obje82_fact { ObjectTerm_obje82[  ] }
fact ObjectTerm_obje91_fact { ObjectTerm_obje91[  ] }
fact ObjectTerm_obje92_fact { ObjectTerm_obje92[  ] }
fact ObjectTerm_obje101_fact { ObjectTerm_obje101[  ] }
fact ObjectTerm_obje102_fact { ObjectTerm_obje102[  ] }
fact ObjectTerm_obje111_fact { ObjectTerm_obje111[  ] }
fact ObjectTerm_obje112_fact { ObjectTerm_obje112[  ] }
fact ObjectTerm_obje121_fact { ObjectTerm_obje121[  ] }
fact ObjectTerm_obje122_fact { ObjectTerm_obje122[  ] }
fact ObjectTerm_obje131_fact { ObjectTerm_obje131[  ] }
fact ObjectTerm_obje132_fact { ObjectTerm_obje132[  ] }
fact ObjectTerm_obje141_fact { ObjectTerm_obje141[  ] }
fact ObjectTerm_obje142_fact { ObjectTerm_obje142[  ] }
fact ObjectTerm_obje151_fact { ObjectTerm_obje151[  ] }
fact ObjectTerm_obje152_fact { ObjectTerm_obje152[  ] }
fact ObjectTerm_obje161_fact { ObjectTerm_obje161[  ] }
fact ObjectTerm_obje162_fact { ObjectTerm_obje162[  ] }
fact DataTerm_data1_fact { DataTerm_data1[  ] }
fact DataTerm_data2_fact { DataTerm_data2[  ] }
fact DataTerm_data21_fact { DataTerm_data21[  ] }
fact DataTerm_data22_fact { DataTerm_data22[  ] }
fact DataTerm_data31_fact { DataTerm_data31[  ] }
fact DataTerm_data32_fact { DataTerm_data32[  ] }
fact DataTerm_data41_fact { DataTerm_data41[  ] }
fact DataTerm_data42_fact { DataTerm_data42[  ] }
fact DataTerm_data51_fact { DataTerm_data51[  ] }
fact DataTerm_data52_fact { DataTerm_data52[  ] }
fact Slot_slot1_fact { Slot_slot1[  ] }
fact Slot_slot2_fact { Slot_slot2[  ] }
fact Slot_slot21_fact { Slot_slot21[  ] }
fact Slot_slot22_fact { Slot_slot22[  ] }
fact Slot_slot31_fact { Slot_slot31[  ] }
fact Slot_slot32_fact { Slot_slot32[  ] }
fact Term_term1_fact { Term_term1[  ] }
fact Term_term2_fact { Term_term2[  ] }
fact Term_term21_fact { Term_term21[  ] }
fact Term_term22_fact { Term_term22[  ] }
fact Term_term31_fact { Term_term31[  ] }
fact Term_term32_fact { Term_term32[  ] }
fact DataVariable_datag1_fact { DataVariable_datag1[  ] }
fact GenericVariable_newConstraint_fact { GenericVariable_newConstraint[  ] }
fact ObjectVariable_objeg1_fact { ObjectVariable_objeg1[  ] }
fact ObjectName_objeg1_fact { ObjectName_objeg1[  ] }
fact DataLiteral_data1_fact { DataLiteral_data1[  ] }
fact DataLiteral_data2_fact { DataLiteral_data2[  ] }
fact GenericEntityName_geneg1_fact { GenericEntityName_geneg1[  ] }
fact Property_propg1_fact { Property_propg1[  ] }
fact VocabularyEntery_voca1_fact { VocabularyEntery_voca1[  ] }
fact VocabularyEntery_voca2_fact { VocabularyEntery_voca2[  ] }
fact Asso_Vocabulary_vocabulary_rulebase_RuleBase { RuleBase <: vocabulary in  ( RuleBase) one->lone ( Vocabulary) }
fact Asso_RuleSet_ruleset_rulebase_RuleBase { RuleSet <: rulebase in  ( RuleSet) set->one ( RuleBase) && RuleBase <: ruleset in  ( RuleBase) one->set ( RuleSet) }
fact Asso_RuleBase_rulebase_externalvocabulary_ExternalVocabulary { RuleBase <: externalvocabulary in  ( RuleBase) one->set ( ExternalVocabulary) }
fact Asso_Variable_variable_ruleset_RuleSet { Variable <: ruleset in  ( Variable) set->set ( RuleSet) && RuleSet <: variable in  ( RuleSet) set->set ( Variable) }
fact Asso_RuleSet_ruleset_vocabulary_Vocabulary { RuleSet <: vocabulary in  ( RuleSet) one->lone ( Vocabulary) }
fact Asso_IntegrityRuleSet_integrityruleset_integrityrule_IntegrityRule { IntegrityRuleSet <: integrityrule in  ( IntegrityRuleSet) set->set ( IntegrityRule) }
fact Asso_DerivationRuleSet_derivationruleset_derivationrule_DerivationRule { DerivationRuleSet <: derivationrule in  ( DerivationRuleSet) set->set ( DerivationRule) }
fact Asso_ProductionRuleSet_productionruleset_productionrule_ProductionRule { ProductionRuleSet <: productionrule in  ( ProductionRuleSet) set->set ( ProductionRule) }
fact Asso_ReactionRuleSet_reactionruleset_reactionrule_ReactionRule { ReactionRuleSet <: reactionrule in  ( ReactionRuleSet) set->set ( ReactionRule) }
fact Asso_RuleSet_ruleset_externalvocabulary_ExternalVocabulary { RuleSet <: externalvocabulary in  ( RuleSet) set->one ( ExternalVocabulary) }
fact Asso_IntegrityRule_integrityrule_logicalformula_LogicalFormula { IntegrityRule <: logicalformula in  ( IntegrityRule) set->one ( LogicalFormula) }
fact Asso_AndOrNafNegFormula_andornafnegformula_derivationrule_DerivationRule { DerivationRule <: andornafnegformula in  ( DerivationRule) set->some ( AndOrNafNegFormula) }
fact Asso_DerivationRule_derivationrule_literalconjunction_LiteralConjunction { DerivationRule <: literalconjunction in  ( DerivationRule) set->one ( LiteralConjunction) }
fact Asso_AndOrNafNegFormula_andornafnegformula_productionrule_ProductionRule { ProductionRule <: andornafnegformula in  ( ProductionRule) set->some ( AndOrNafNegFormula) }
fact Asso_ProductionRule_productionrule_programactionexpression_ProgramActionExpression { ProductionRule <: programactionexpression in  ( ProductionRule) set->some ( ProgramActionExpression) }
fact Asso_ProductionRule_productionrule_andornafnegformula_AndOrNafNegFormula { ProductionRule <: andornafnegformula in  ( ProductionRule) set->set ( AndOrNafNegFormula) }
fact Asso_ReactionRule_reactionrule_andornafnegformula_AndOrNafNegFormula { ReactionRule <: andornafnegformula in  ( ReactionRule) one->some ( AndOrNafNegFormula) }
fact Asso_AndOrNafNegFormula_andornafnegformula_reactionrule_ReactionRule { ReactionRule <: andornafnegformula in  ( ReactionRule) one->set ( AndOrNafNegFormula) }
fact Asso_ReactionRule_reactionrule_eventexpression_EventExpression { ReactionRule <: eventexpression in  ( ReactionRule) one->one ( EventExpression) }
fact Asso_EventExpression_eventexpression_reactionrule_ReactionRule { ReactionRule <: eventexpression in  ( ReactionRule) one->one ( EventExpression) }
fact Asso_Conjunction_conjunction_logicalformula_LogicalFormula { Conjunction <: logicalformula in  ( Conjunction) one->set ( LogicalFormula) }
fact Asso_LogicalFormula_logicalformula_disjunction_Disjunction { Disjunction <: logicalformula in  ( Disjunction) one->one ( LogicalFormula) }
fact Asso_LogicalFormula_logicalformula_negationasfailure_NegationAsFailure { NegationAsFailure <: logicalformula in  ( NegationAsFailure) one->one ( LogicalFormula) }
fact Asso_LogicalFormula_logicalformula_strongnegation_StrongNegation { StrongNegation <: logicalformula in  ( StrongNegation) one->one ( LogicalFormula) }
fact Asso_LogicalFormula_logicalformula_implication_Implication { Implication <: logicalformula in  ( Implication) one->one ( LogicalFormula) }
fact Asso_QuantifiedFormula_quantifiedformula_logicalformula_LogicalFormula { QuantifiedFormula <: logicalformula in  ( QuantifiedFormula) one->one ( LogicalFormula) }
fact Asso_LogicalFormula_logicalformula_implication_Implication { LogicalFormula <: implication in  ( LogicalFormula) one->one ( Implication) && Implication <: logicalformula in  ( Implication) one->one ( LogicalFormula) }
fact Asso_QuantifiedFormula_quantifiedformula_variable_Variable { QuantifiedFormula <: variable in  ( QuantifiedFormula) one->one ( Variable) }
fact Asso_AndOrNafNegFormula_andornafnegformula_conjunction_Conjunction { Conjunction <: andornafnegformula in  ( Conjunction) one->set ( AndOrNafNegFormula) }
fact Asso_Disjunction_disjunction_andornafnegformula_AndOrNafNegFormula { Disjunction <: andornafnegformula in  ( Disjunction) one->set ( AndOrNafNegFormula) }
fact Asso_Negation_negation_andornafnegformula_AndOrNafNegFormula { Negation <: andornafnegformula in  ( Negation) one->one ( AndOrNafNegFormula) }
fact Asso_Atom_atom_literalconjunction_LiteralConjunction { LiteralConjunction <: atom in  ( LiteralConjunction) one->some ( Atom) }
fact Asso_Class_class_objectclassificationatom_ObjectClassificationAtom { Class <: objectclassificationatom in  ( Class) one->set ( ObjectClassificationAtom) && ObjectClassificationAtom <: class in  ( ObjectClassificationAtom) set->one ( Class) }
fact Asso_ObjectClassificationAtom_objectclassificationatom_objectterm_ObjectTerm { ObjectClassificationAtom <: objectterm in  ( ObjectClassificationAtom) one->one ( ObjectTerm) }
fact Asso_DataClassificationAtom_dataclassificationatom_dataterm_DataTerm { DataClassificationAtom <: dataterm in  ( DataClassificationAtom) one->one ( DataTerm) }
fact Asso_DataType_datatype_dataclassificationatom_DataClassificationAtom { DataType <: dataclassificationatom in  ( DataType) one->set ( DataClassificationAtom) && DataClassificationAtom <: datatype in  ( DataClassificationAtom) set->one ( DataType) }
fact Asso_ReferencePropertyAtom_referencepropertyatom_objectterm_ObjectTerm { ReferencePropertyAtom <: objectterm in  ( ReferencePropertyAtom) one->one ( ObjectTerm) }
fact Asso_ObjectTerm_objectterm_referencepropertyatom_ReferencePropertyAtom { ReferencePropertyAtom <: objectterm in  ( ReferencePropertyAtom) one->one ( ObjectTerm) }
fact Asso_ReferenceProperty_referenceproperty_referencepropertyatom_ReferencePropertyAtom { ReferenceProperty <: referencepropertyatom in  ( ReferenceProperty) some->one ( ReferencePropertyAtom) && ReferencePropertyAtom <: referenceproperty in  ( ReferencePropertyAtom) one->some ( ReferenceProperty) }
fact Asso_AttributionAtom_attributionatom_dataterm_DataTerm { AttributionAtom <: dataterm in  ( AttributionAtom) one->one ( DataTerm) }
fact Asso_ObjectTerm_objectterm_attributionatom_AttributionAtom { ObjectTerm <: attributionatom in  ( ObjectTerm) one->one ( AttributionAtom) && AttributionAtom <: objectterm in  ( AttributionAtom) one->one ( ObjectTerm) }
fact Asso_ObjectTerm_objectterm_attributionatom_AttributionAtom { AttributionAtom <: objectterm in  ( AttributionAtom) one->one ( ObjectTerm) }
fact Asso_AttributionAtom_attributionatom_attribute_Attribute { AttributionAtom <: attribute in  ( AttributionAtom) set->one ( Attribute) && Attribute <: attributionatom in  ( Attribute) one->set ( AttributionAtom) }
fact Asso_Class_class_objectdescriptionatom_ObjectDescriptionAtom { Class <: objectdescriptionatom in  ( Class) lone->one ( ObjectDescriptionAtom) && ObjectDescriptionAtom <: class in  ( ObjectDescriptionAtom) one->lone ( Class) }
fact Asso_Class_class_objectdescriptionatom_ObjectDescriptionAtom { Class <: objectdescriptionatom in  ( Class) set->one ( ObjectDescriptionAtom) && ObjectDescriptionAtom <: class in  ( ObjectDescriptionAtom) one->set ( Class) }
fact Asso_ObjectSlot_objectslot_referenceproperty_ReferenceProperty { ObjectSlot <: referenceproperty in  ( ObjectSlot) set->one ( ReferenceProperty) && ReferenceProperty <: objectslot in  ( ReferenceProperty) one->set ( ObjectSlot) }
fact Asso_ObjectTerm_objectterm_objectslot_ObjectSlot { ObjectSlot <: objectterm in  ( ObjectSlot) one->one ( ObjectTerm) }
fact Asso_ObjectDescriptionAtom_objectdescriptionatom_objectterm_ObjectTerm { ObjectDescriptionAtom <: objectterm in  ( ObjectDescriptionAtom) one->one ( ObjectTerm) }
fact Asso_Slot_slot_objectdescriptionatom_ObjectDescriptionAtom { ObjectDescriptionAtom <: slot in  ( ObjectDescriptionAtom) one->some ( Slot) }
fact Asso_DataTerm_dataterm_dataslot_DataSlot { DataSlot <: dataterm in  ( DataSlot) one->one ( DataTerm) }
fact Asso_DataSlot_dataslot_attribute_Attribute { DataSlot <: attribute in  ( DataSlot) set->one ( Attribute) && Attribute <: dataslot in  ( Attribute) one->set ( DataSlot) }
fact Asso_EqualityAtom_equalityatom_objectterm_ObjectTerm { EqualityAtom <: objectterm in  ( EqualityAtom) one->set ( ObjectTerm) }
fact Asso_ObjectTerm_objectterm_inequalityatom_InequalityAtom { InequalityAtom <: objectterm in  ( InequalityAtom) one->set ( ObjectTerm) }
fact Asso_GenericAtom_genericatom_genericpredicate_GenericPredicate { GenericAtom <: genericpredicate in  ( GenericAtom) set->one ( GenericPredicate) && GenericPredicate <: genericatom in  ( GenericPredicate) one->set ( GenericAtom) }
fact Asso_GenericAtom_genericatom_term_Term { GenericAtom <: term in  ( GenericAtom) set->set ( Term) }
fact Asso_GenericPredicate_genericpredicate_predicatetypeenumerationliteral_PredicateTypeEnumerationLiteral { GenericPredicate <: predicatetypeenumerationliteral in  ( GenericPredicate) set->lone ( PredicateTypeEnumerationLiteral) }
fact Asso_AssociationAtom_associationatom_objectterm_ObjectTerm { AssociationAtom <: objectterm in  ( AssociationAtom) set->set ( ObjectTerm) }
fact Asso_DataTerm_dataterm_associationatom_AssociationAtom { AssociationAtom <: dataterm in  ( AssociationAtom) set->set ( DataTerm) }
fact Asso_AssociationPredicate_associationpredicate_associationatom_AssociationAtom { AssociationPredicate <: associationatom in  ( AssociationPredicate) one->set ( AssociationAtom) && AssociationAtom <: associationpredicate in  ( AssociationAtom) set->one ( AssociationPredicate) }
fact Asso_DatatypePredicateAtom_datatypepredicateatom_dataterm_DataTerm { DatatypePredicateAtom <: dataterm in  ( DatatypePredicateAtom) one->some ( DataTerm) }
fact Asso_DatatypePredicate_datatypepredicate_datatypepredicateatom_DatatypePredicateAtom { DatatypePredicate <: datatypepredicateatom in  ( DatatypePredicate) one->set ( DatatypePredicateAtom) && DatatypePredicateAtom <: datatypepredicate in  ( DatatypePredicateAtom) set->one ( DatatypePredicate) }
fact Asso_ObjectTerm_objectterm_referencepropertyfunctionterm_ReferencePropertyFunctionTerm { ReferencePropertyFunctionTerm <: objectterm in  ( ReferencePropertyFunctionTerm) one->one ( ObjectTerm) }
fact Asso_ReferencePropertyFunctionTerm_referencepropertyfunctionterm_referenceproperty_ReferenceProperty { ReferencePropertyFunctionTerm <: referenceproperty in  ( ReferencePropertyFunctionTerm) set->one ( ReferenceProperty) && ReferenceProperty <: referencepropertyfunctionterm in  ( ReferenceProperty) one->set ( ReferencePropertyFunctionTerm) }
fact Asso_ObjectTerm_objectterm_objectoperationterm_ObjectOperationTerm { ObjectOperationTerm <: objectterm in  ( ObjectOperationTerm) one->lone ( ObjectTerm) }
fact Asso_Term_term_objectoperationterm_ObjectOperationTerm { ObjectOperationTerm <: term in  ( ObjectOperationTerm) one->set ( Term) }
fact Asso_ObjectOperationTerm_objectoperationterm_objectoperation_ObjectOperation { ObjectOperationTerm <: objectoperation in  ( ObjectOperationTerm) set->one ( ObjectOperation) && ObjectOperation <: objectoperationterm in  ( ObjectOperation) one->set ( ObjectOperationTerm) }
fact Asso_ObjectVariable_objectvariable_class_Class { ObjectVariable <: class in  ( ObjectVariable) set->lone ( Class) && Class <: objectvariable in  ( Class) lone->set ( ObjectVariable) }
fact Asso_Class_class_objectname_ObjectName { Class <: objectname in  ( Class) one->set ( ObjectName) && ObjectName <: class in  ( ObjectName) set->one ( Class) }
fact Asso_DataType_datatype_datavariable_DataVariable { DataType <: datavariable in  ( DataType) lone->set ( DataVariable) && DataVariable <: datatype in  ( DataVariable) set->lone ( DataType) }
fact Asso_DataType_datatype_typedliteral_TypedLiteral { DataType <: typedliteral in  ( DataType) one->set ( TypedLiteral) && TypedLiteral <: datatype in  ( TypedLiteral) set->one ( DataType) }
fact Asso_DataOperationTerm_dataoperationterm_objectterm_ObjectTerm { DataOperationTerm <: objectterm in  ( DataOperationTerm) one->one ( ObjectTerm) }
fact Asso_Term_term_dataoperationterm_DataOperationTerm { DataOperationTerm <: term in  ( DataOperationTerm) set->some ( Term) }
fact Asso_ObjectTerm_objectterm_attributefunctionterm_AttributeFunctionTerm { AttributeFunctionTerm <: objectterm in  ( AttributeFunctionTerm) some->one ( ObjectTerm) }
fact Asso_Attribute_attribute_attributefunctionterm_AttributeFunctionTerm { Attribute <: attributefunctionterm in  ( Attribute) one->one ( AttributeFunctionTerm) && AttributeFunctionTerm <: attribute in  ( AttributeFunctionTerm) one->one ( Attribute) }
fact Asso_DataOperationTerm_dataoperationterm_dataoperation_DataOperation { DataOperationTerm <: dataoperation in  ( DataOperationTerm) set->one ( DataOperation) && DataOperation <: dataoperationterm in  ( DataOperation) one->set ( DataOperationTerm) }
fact Asso_DataTypeFunction_datatypefunction_datatypefuncionterm_DataTypeFuncionTerm { DataTypeFunction <: datatypefuncionterm in  ( DataTypeFunction) one->set ( DataTypeFuncionTerm) && DataTypeFuncionTerm <: datatypefunction in  ( DataTypeFuncionTerm) set->one ( DataTypeFunction) }
fact Asso_DataTerm_dataterm_datatypefuncionterm_DataTypeFuncionTerm { DataTypeFuncionTerm <: dataterm in  ( DataTypeFuncionTerm) one->some ( DataTerm) }
fact Asso_Type_type_genericentityname_GenericEntityName { Type <: genericentityname in  ( Type) lone->set ( GenericEntityName) && GenericEntityName <: type in  ( GenericEntityName) set->lone ( Type) }
fact Asso_GenericVariable_genericvariable_type_Type { GenericVariable <: type in  ( GenericVariable) set->lone ( Type) && Type <: genericvariable in  ( Type) lone->set ( GenericVariable) }
fact Asso_GenericFunction_genericfunction_genericfunctionterm_GenericFunctionTerm { GenericFunction <: genericfunctionterm in  ( GenericFunction) one->one ( GenericFunctionTerm) && GenericFunctionTerm <: genericfunction in  ( GenericFunctionTerm) one->one ( GenericFunction) }
fact Asso_GenericFunctionTerm_genericfunctionterm_genericterm_GenericTerm { GenericFunctionTerm <: genericterm in  ( GenericFunctionTerm) set->one ( GenericTerm) }
fact Asso_EventType_eventtype_atomiceventexpression_AtomicEventExpression { EventType <: atomiceventexpression in  ( EventType) set->one ( AtomicEventExpression) && AtomicEventExpression <: eventtype in  ( AtomicEventExpression) one->set ( EventType) }
fact Asso_AtomicEventExpression_atomiceventexpression_objectterm_ObjectTerm { AtomicEventExpression <: objectterm in  ( AtomicEventExpression) one->one ( ObjectTerm) && ObjectTerm <: atomiceventexpression in  ( ObjectTerm) one->one ( AtomicEventExpression) }
fact Asso_AndNotEventExpression_andnoteventexpression_eventexpression_EventExpression { AndNotEventExpression <: eventexpression in  ( AndNotEventExpression) one->set ( EventExpression) }
fact Asso_AtomicEventExpression_atomiceventexpression_slot_Slot { AtomicEventExpression <: slot in  ( AtomicEventExpression) one->one ( Slot) }
fact Asso_EventExpression_eventexpression_sequenceeventexpression_SequenceEventExpression { SequenceEventExpression <: eventexpression in  ( SequenceEventExpression) one->set ( EventExpression) }
fact Asso_ChoiceEventExpression_choiceeventexpression_eventexpression_EventExpression { ChoiceEventExpression <: eventexpression in  ( ChoiceEventExpression) one->some ( EventExpression) }
fact Asso_ParallelEventExpression_paralleleventexpression_eventexpression_EventExpression { ParallelEventExpression <: eventexpression in  ( ParallelEventExpression) one->set ( EventExpression) }
fact Asso_InvokeActionExpression_invokeactionexpression_operation_Operation { InvokeActionExpression <: operation in  ( InvokeActionExpression) one->set ( Operation) && Operation <: invokeactionexpression in  ( Operation) set->one ( InvokeActionExpression) }
fact Asso_Term_term_invokeactionexpression_InvokeActionExpression { InvokeActionExpression <: term in  ( InvokeActionExpression) one->one ( Term) }
fact Asso_UpdateActionExpr_updateactionexpr_term_Term { UpdateActionExpr <: term in  ( UpdateActionExpr) one->one ( Term) }
fact Asso_Property_property_updateactionexpr_UpdateActionExpr { Property <: updateactionexpr in  ( Property) one->set ( UpdateActionExpr) && UpdateActionExpr <: property in  ( UpdateActionExpr) set->one ( Property) }
fact Asso_ObjectTerm_objectterm_updateactionexpr_UpdateActionExpr { UpdateActionExpr <: objectterm in  ( UpdateActionExpr) one->one ( ObjectTerm) }
fact Asso_ObjectTerm_objectterm_assertactionexpression_AssertActionExpression { AssertActionExpression <: objectterm in  ( AssertActionExpression) one->one ( ObjectTerm) }
fact Asso_RetractActionExpression_retractactionexpression_objectterm_ObjectTerm { RetractActionExpression <: objectterm in  ( RetractActionExpression) one->one ( ObjectTerm) }
fact Asso_Class_class_retractactionexpression_RetractActionExpression { Class <: retractactionexpression in  ( Class) one->set ( RetractActionExpression) && RetractActionExpression <: class in  ( RetractActionExpression) set->one ( Class) }
fact Asso_AssertActionExpression_assertactionexpression_class_Class { AssertActionExpression <: class in  ( AssertActionExpression) set->one ( Class) && Class <: assertactionexpression in  ( Class) one->set ( AssertActionExpression) }
fact Asso_Slot_slot_assertactionexpression_AssertActionExpression { Slot <: assertactionexpression in  ( Slot) set->one ( AssertActionExpression) && AssertActionExpression <: slot in  ( AssertActionExpression) one->set ( Slot) }
fact Asso_InvokeActionExpression_invokeactionexpression_objectterm_ObjectTerm { InvokeActionExpression <: objectterm in  ( InvokeActionExpression) one->lone ( ObjectTerm) }
fact Asso_MessageType_messagetype_messagetypetype_MessageTypeType { MessageType <: messagetypetype in  ( MessageType) set->one ( MessageTypeType) && MessageTypeType <: messagetype in  ( MessageTypeType) one->set ( MessageType) }
fact Asso_AssociationPredicate_associationpredicate_type_Type { AssociationPredicate <: type in  ( AssociationPredicate) set->set ( Type) && Type <: associationpredicate in  ( Type) set->set ( AssociationPredicate) }
fact Asso_GenericPredicate_genericpredicate_type_Type { GenericPredicate <: type in  ( GenericPredicate) set->set ( Type) && Type <: genericpredicate in  ( Type) set->set ( GenericPredicate) }
fact Asso_DatatypePredicate_datatypepredicate_type_Type { DatatypePredicate <: type in  ( DatatypePredicate) set->some ( Type) && Type <: datatypepredicate in  ( Type) some->set ( DatatypePredicate) }
fact Asso_Property_property_type_Type { Property <: type in  ( Property) set->lone ( Type) && Type <: property in  ( Type) lone->set ( Property) }
fact Asso_Class_class_property_Property { Class <: property in  ( Class) lone->set ( Property) && Property <: class in  ( Property) set->lone ( Class) }
fact Asso_Vocabulary_vocabulary_vocabularyentery_VocabularyEntery { Vocabulary <: vocabularyentery in  ( Vocabulary) one->some ( VocabularyEntery) && VocabularyEntery <: vocabulary in  ( VocabularyEntery) some->one ( Vocabulary) }
fact Asso_EnumerationDatatype_enumerationdatatype_dataliteral_DataLiteral { EnumerationDatatype <: dataliteral in  ( EnumerationDatatype) one->set ( DataLiteral) && DataLiteral <: enumerationdatatype in  ( DataLiteral) set->one ( EnumerationDatatype) }
fact Asso_Class_class_operation_Operation { Class <: operation in  ( Class) lone->set ( Operation) && Operation <: class in  ( Operation) set->lone ( Class) }
fact Asso_Class_class_objectoperation_ObjectOperation { Class <: objectoperation in  ( Class) one->set ( ObjectOperation) && ObjectOperation <: class in  ( ObjectOperation) set->one ( Class) }
fact Asso_DataType_datatype_dataoperation_DataOperation { DataType <: dataoperation in  ( DataType) one->set ( DataOperation) && DataOperation <: datatype in  ( DataOperation) set->one ( DataType) }
fact Asso_GenericFunction_genericfunction_type_Type { GenericFunction <: type in  ( GenericFunction) set->set ( Type) && Type <: genericfunction in  ( Type) set->set ( GenericFunction) }
fact Asso_Type_type_datatypefunction_DataTypeFunction { Type <: datatypefunction in  ( Type) set->set ( DataTypeFunction) && DataTypeFunction <: type in  ( DataTypeFunction) set->set ( Type) }
fact Asso_ObjectClassificationAtom_objectclassificationatom_actor_Actor { ObjectClassificationAtom <: actor in  ( ObjectClassificationAtom) one->one ( Actor) && Actor <: objectclassificationatom in  ( Actor) one->one ( ObjectClassificationAtom) }
fact Asso_ObjectClassificationAtom_objectclassificationatom_action_Action { ObjectClassificationAtom <: action in  ( ObjectClassificationAtom) one->one ( Action) && Action <: objectclassificationatom in  ( Action) one->one ( ObjectClassificationAtom) }
fact Asso_Policy_policy_action_Action { Policy <: action in  ( Policy) one->one ( Action) && Action <: policy in  ( Action) one->one ( Policy) }
fact Asso_Policy_policy_action_Action { Policy <: action in  ( Policy) set->one ( Action) && Action <: policy in  ( Action) one->set ( Policy) }
fact Asso_Action_action_obligationordispensation_ObligationOrDispensation { Action <: obligationordispensation in  ( Action) one->one ( ObligationOrDispensation) && ObligationOrDispensation <: action in  ( ObligationOrDispensation) one->one ( Action) }
fact Asso_EventExpression_eventexpression_obligationordispensation_ObligationOrDispensation { EventExpression <: obligationordispensation in  ( EventExpression) one->one ( ObligationOrDispensation) && ObligationOrDispensation <: eventexpression in  ( ObligationOrDispensation) one->one ( EventExpression) }
fact Asso_Policy_policy_objectdescriptionatom_ObjectDescriptionAtom { Policy <: objectdescriptionatom in  ( Policy) one->one ( ObjectDescriptionAtom) && ObjectDescriptionAtom <: policy in  ( ObjectDescriptionAtom) one->one ( Policy) }
fact Asso_ObjectDescriptionAtom_objectdescriptionatom_derivationrule_DerivationRule { ObjectDescriptionAtom <: derivationrule in  ( ObjectDescriptionAtom) one->one ( DerivationRule) && DerivationRule <: objectdescriptionatom in  ( DerivationRule) one->one ( ObjectDescriptionAtom) }
fact Asso_LogicalFormula_logicalformula_derivationrule_DerivationRule { LogicalFormula <: derivationrule in  ( LogicalFormula) one->one ( DerivationRule) && DerivationRule <: logicalformula in  ( DerivationRule) one->one ( LogicalFormula) }
fact Asso_Content_content_policy_Policy { Content <: policy in  ( Content) one->one ( Policy) && Policy <: content in  ( Policy) one->one ( Content) }
fact Asso_Action_action_entity_Entity { Action <: entity in  ( Action) one->one ( Entity) && Entity <: action in  ( Entity) one->one ( Action) }
fact Asso_Action_action_entity_Entity { Action <: entity in  ( Action) one->one ( Entity) && Entity <: action in  ( Entity) one->one ( Action) }
fact Asso_Action_action_entity_Entity { Action <: entity in  ( Action) one->one ( Entity) && Entity <: action in  ( Entity) one->one ( Action) }
fact Asso_Predicate_predicate_property_Property { Predicate <: property in  ( Predicate) one->lone ( Property) && Property <: predicate in  ( Property) lone->one ( Predicate) }
fact Asso_Negation_negation_strongnegation_StrongNegation { Negation <: strongnegation in  ( Negation) one->lone ( StrongNegation) && StrongNegation <: negation in  ( StrongNegation) lone->one ( Negation) }
fact Asso_PropertyAtom_propertyatom_referencepropertyatom_ReferencePropertyAtom { PropertyAtom <: referencepropertyatom in  ( PropertyAtom) one->lone ( ReferencePropertyAtom) && ReferencePropertyAtom <: propertyatom in  ( ReferencePropertyAtom) lone->one ( PropertyAtom) }
fact Asso_Variable_variable_objectvariable_ObjectVariable { Variable <: objectvariable in  ( Variable) one->lone ( ObjectVariable) && ObjectVariable <: variable in  ( ObjectVariable) lone->one ( Variable) }
fact Asso_VocabularyEntery_vocabularyentery_objectname_ObjectName { VocabularyEntery <: objectname in  ( VocabularyEntery) one->lone ( ObjectName) && ObjectName <: vocabularyentery in  ( ObjectName) lone->one ( VocabularyEntery) }
fact Asso_NegationAsFailure_negationasfailure_negation_Negation { NegationAsFailure <: negation in  ( NegationAsFailure) lone->one ( Negation) && Negation <: negationasfailure in  ( Negation) one->lone ( NegationAsFailure) }
fact Asso_GenericVariable_genericvariable_variable_Variable { GenericVariable <: variable in  ( GenericVariable) lone->one ( Variable) && Variable <: genericvariable in  ( Variable) one->lone ( GenericVariable) }
fact Asso_VocabularyEntery_vocabularyentery_genericentityname_GenericEntityName { VocabularyEntery <: genericentityname in  ( VocabularyEntery) one->lone ( GenericEntityName) && GenericEntityName <: vocabularyentery in  ( GenericEntityName) lone->one ( VocabularyEntery) }
fact Asso_AndOrNafNegFormula_andornafnegformula_disjunction_Disjunction { AndOrNafNegFormula <: disjunction in  ( AndOrNafNegFormula) one->lone ( Disjunction) && Disjunction <: andornafnegformula in  ( Disjunction) lone->one ( AndOrNafNegFormula) }
fact Asso_Variable_variable_datavariable_DataVariable { Variable <: datavariable in  ( Variable) one->one ( DataVariable) && DataVariable <: variable in  ( DataVariable) one->one ( Variable) }
fact Asso_Conjunction_conjunction_andornafnegformula_AndOrNafNegFormula { Conjunction <: andornafnegformula in  ( Conjunction) lone->one ( AndOrNafNegFormula) && AndOrNafNegFormula <: conjunction in  ( AndOrNafNegFormula) one->lone ( Conjunction) }
fact Asso_AndOrNafNegFormula_andornafnegformula_atom_Atom { AndOrNafNegFormula <: atom in  ( AndOrNafNegFormula) one->lone ( Atom) && Atom <: andornafnegformula in  ( Atom) lone->one ( AndOrNafNegFormula) }
fact Asso_AtleastQuantifiedFormula_atleastquantifiedformula_atleastandatmostquantifiedformula_AtLeastAndAtMostQuantifiedFormula { AtleastQuantifiedFormula <: atleastandatmostquantifiedformula in  ( AtleastQuantifiedFormula) one->lone ( AtLeastAndAtMostQuantifiedFormula) && AtLeastAndAtMostQuantifiedFormula <: atleastquantifiedformula in  ( AtLeastAndAtMostQuantifiedFormula) lone->one ( AtleastQuantifiedFormula) }
fact RuleSet_ruleset_rulebase_RuleBase_symmetry { RuleBase <: ruleset = ~(RuleSet <: rulebase) }
fact Variable_variable_ruleset_RuleSet_symmetry { RuleSet <: variable = ~(Variable <: ruleset) }
fact LogicalFormula_logicalformula_implication_Implication_symmetry { Implication <: logicalformula = ~(LogicalFormula <: implication) }
fact Class_class_objectclassificationatom_ObjectClassificationAtom_symmetry { ObjectClassificationAtom <: class = ~(Class <: objectclassificationatom) }
fact DataType_datatype_dataclassificationatom_DataClassificationAtom_symmetry { DataClassificationAtom <: datatype = ~(DataType <: dataclassificationatom) }
fact ReferenceProperty_referenceproperty_referencepropertyatom_ReferencePropertyAtom_symmetry { ReferencePropertyAtom <: referenceproperty = ~(ReferenceProperty <: referencepropertyatom) }
fact ObjectTerm_objectterm_attributionatom_AttributionAtom_symmetry { AttributionAtom <: objectterm = ~(ObjectTerm <: attributionatom) }
fact AttributionAtom_attributionatom_attribute_Attribute_symmetry { Attribute <: attributionatom = ~(AttributionAtom <: attribute) }
fact Class_class_objectdescriptionatom_ObjectDescriptionAtom_symmetry { ObjectDescriptionAtom <: class = ~(Class <: objectdescriptionatom) }
fact Class_class_objectdescriptionatom_ObjectDescriptionAtom_symmetry { ObjectDescriptionAtom <: class = ~(Class <: objectdescriptionatom) }
fact ObjectSlot_objectslot_referenceproperty_ReferenceProperty_symmetry { ReferenceProperty <: objectslot = ~(ObjectSlot <: referenceproperty) }
fact DataSlot_dataslot_attribute_Attribute_symmetry { Attribute <: dataslot = ~(DataSlot <: attribute) }
fact GenericAtom_genericatom_genericpredicate_GenericPredicate_symmetry { GenericPredicate <: genericatom = ~(GenericAtom <: genericpredicate) }
fact AssociationPredicate_associationpredicate_associationatom_AssociationAtom_symmetry { AssociationAtom <: associationpredicate = ~(AssociationPredicate <: associationatom) }
fact DatatypePredicate_datatypepredicate_datatypepredicateatom_DatatypePredicateAtom_symmetry { DatatypePredicateAtom <: datatypepredicate = ~(DatatypePredicate <: datatypepredicateatom) }
fact ReferencePropertyFunctionTerm_referencepropertyfunctionterm_referenceproperty_ReferenceProperty_symmetry { ReferenceProperty <: referencepropertyfunctionterm = ~(ReferencePropertyFunctionTerm <: referenceproperty) }
fact ObjectOperationTerm_objectoperationterm_objectoperation_ObjectOperation_symmetry { ObjectOperation <: objectoperationterm = ~(ObjectOperationTerm <: objectoperation) }
fact ObjectVariable_objectvariable_class_Class_symmetry { Class <: objectvariable = ~(ObjectVariable <: class) }
fact Class_class_objectname_ObjectName_symmetry { ObjectName <: class = ~(Class <: objectname) }
fact DataType_datatype_datavariable_DataVariable_symmetry { DataVariable <: datatype = ~(DataType <: datavariable) }
fact DataType_datatype_typedliteral_TypedLiteral_symmetry { TypedLiteral <: datatype = ~(DataType <: typedliteral) }
fact Attribute_attribute_attributefunctionterm_AttributeFunctionTerm_symmetry { AttributeFunctionTerm <: attribute = ~(Attribute <: attributefunctionterm) }
fact DataOperationTerm_dataoperationterm_dataoperation_DataOperation_symmetry { DataOperation <: dataoperationterm = ~(DataOperationTerm <: dataoperation) }
fact DataTypeFunction_datatypefunction_datatypefuncionterm_DataTypeFuncionTerm_symmetry { DataTypeFuncionTerm <: datatypefunction = ~(DataTypeFunction <: datatypefuncionterm) }
fact Type_type_genericentityname_GenericEntityName_symmetry { GenericEntityName <: type = ~(Type <: genericentityname) }
fact GenericVariable_genericvariable_type_Type_symmetry { Type <: genericvariable = ~(GenericVariable <: type) }
fact GenericFunction_genericfunction_genericfunctionterm_GenericFunctionTerm_symmetry { GenericFunctionTerm <: genericfunction = ~(GenericFunction <: genericfunctionterm) }
fact EventType_eventtype_atomiceventexpression_AtomicEventExpression_symmetry { AtomicEventExpression <: eventtype = ~(EventType <: atomiceventexpression) }
fact AtomicEventExpression_atomiceventexpression_objectterm_ObjectTerm_symmetry { ObjectTerm <: atomiceventexpression = ~(AtomicEventExpression <: objectterm) }
fact InvokeActionExpression_invokeactionexpression_operation_Operation_symmetry { Operation <: invokeactionexpression = ~(InvokeActionExpression <: operation) }
fact Property_property_updateactionexpr_UpdateActionExpr_symmetry { UpdateActionExpr <: property = ~(Property <: updateactionexpr) }
fact Class_class_retractactionexpression_RetractActionExpression_symmetry { RetractActionExpression <: class = ~(Class <: retractactionexpression) }
fact AssertActionExpression_assertactionexpression_class_Class_symmetry { Class <: assertactionexpression = ~(AssertActionExpression <: class) }
fact Slot_slot_assertactionexpression_AssertActionExpression_symmetry { AssertActionExpression <: slot = ~(Slot <: assertactionexpression) }
fact MessageType_messagetype_messagetypetype_MessageTypeType_symmetry { MessageTypeType <: messagetype = ~(MessageType <: messagetypetype) }
fact AssociationPredicate_associationpredicate_type_Type_symmetry { Type <: associationpredicate = ~(AssociationPredicate <: type) }
fact GenericPredicate_genericpredicate_type_Type_symmetry { Type <: genericpredicate = ~(GenericPredicate <: type) }
fact DatatypePredicate_datatypepredicate_type_Type_symmetry { Type <: datatypepredicate = ~(DatatypePredicate <: type) }
fact Property_property_type_Type_symmetry { Type <: property = ~(Property <: type) }
fact Class_class_property_Property_symmetry { Property <: class = ~(Class <: property) }
fact Vocabulary_vocabulary_vocabularyentery_VocabularyEntery_symmetry { VocabularyEntery <: vocabulary = ~(Vocabulary <: vocabularyentery) }
fact EnumerationDatatype_enumerationdatatype_dataliteral_DataLiteral_symmetry { DataLiteral <: enumerationdatatype = ~(EnumerationDatatype <: dataliteral) }
fact Class_class_operation_Operation_symmetry { Operation <: class = ~(Class <: operation) }
fact Class_class_objectoperation_ObjectOperation_symmetry { ObjectOperation <: class = ~(Class <: objectoperation) }
fact DataType_datatype_dataoperation_DataOperation_symmetry { DataOperation <: datatype = ~(DataType <: dataoperation) }
fact GenericFunction_genericfunction_type_Type_symmetry { Type <: genericfunction = ~(GenericFunction <: type) }
fact Type_type_datatypefunction_DataTypeFunction_symmetry { DataTypeFunction <: type = ~(Type <: datatypefunction) }
fact ObjectClassificationAtom_objectclassificationatom_actor_Actor_symmetry { Actor <: objectclassificationatom = ~(ObjectClassificationAtom <: actor) }
fact ObjectClassificationAtom_objectclassificationatom_action_Action_symmetry { Action <: objectclassificationatom = ~(ObjectClassificationAtom <: action) }
fact Policy_policy_action_Action_symmetry { Action <: policy = ~(Policy <: action) }
fact Policy_policy_action_Action_symmetry { Action <: policy = ~(Policy <: action) }
fact Action_action_obligationordispensation_ObligationOrDispensation_symmetry { ObligationOrDispensation <: action = ~(Action <: obligationordispensation) }
fact EventExpression_eventexpression_obligationordispensation_ObligationOrDispensation_symmetry { ObligationOrDispensation <: eventexpression = ~(EventExpression <: obligationordispensation) }
fact Policy_policy_objectdescriptionatom_ObjectDescriptionAtom_symmetry { ObjectDescriptionAtom <: policy = ~(Policy <: objectdescriptionatom) }
fact ObjectDescriptionAtom_objectdescriptionatom_derivationrule_DerivationRule_symmetry { DerivationRule <: objectdescriptionatom = ~(ObjectDescriptionAtom <: derivationrule) }
fact LogicalFormula_logicalformula_derivationrule_DerivationRule_symmetry { DerivationRule <: logicalformula = ~(LogicalFormula <: derivationrule) }
fact Content_content_policy_Policy_symmetry { Policy <: content = ~(Content <: policy) }
fact Action_action_entity_Entity_symmetry { Entity <: action = ~(Action <: entity) }
fact Action_action_entity_Entity_symmetry { Entity <: action = ~(Action <: entity) }
fact Action_action_entity_Entity_symmetry { Entity <: action = ~(Action <: entity) }
fact Predicate_predicate_property_Property_symmetry { Property <: predicate = ~(Predicate <: property) }
fact Negation_negation_strongnegation_StrongNegation_symmetry { StrongNegation <: negation = ~(Negation <: strongnegation) }
fact PropertyAtom_propertyatom_referencepropertyatom_ReferencePropertyAtom_symmetry { ReferencePropertyAtom <: propertyatom = ~(PropertyAtom <: referencepropertyatom) }
fact Variable_variable_objectvariable_ObjectVariable_symmetry { ObjectVariable <: variable = ~(Variable <: objectvariable) }
fact VocabularyEntery_vocabularyentery_objectname_ObjectName_symmetry { ObjectName <: vocabularyentery = ~(VocabularyEntery <: objectname) }
fact NegationAsFailure_negationasfailure_negation_Negation_symmetry { Negation <: negationasfailure = ~(NegationAsFailure <: negation) }
fact GenericVariable_genericvariable_variable_Variable_symmetry { Variable <: genericvariable = ~(GenericVariable <: variable) }
fact VocabularyEntery_vocabularyentery_genericentityname_GenericEntityName_symmetry { GenericEntityName <: vocabularyentery = ~(VocabularyEntery <: genericentityname) }
fact AndOrNafNegFormula_andornafnegformula_disjunction_Disjunction_symmetry { Disjunction <: andornafnegformula = ~(AndOrNafNegFormula <: disjunction) }
fact Variable_variable_datavariable_DataVariable_symmetry { DataVariable <: variable = ~(Variable <: datavariable) }
fact Conjunction_conjunction_andornafnegformula_AndOrNafNegFormula_symmetry { AndOrNafNegFormula <: conjunction = ~(Conjunction <: andornafnegformula) }
fact AndOrNafNegFormula_andornafnegformula_atom_Atom_symmetry { Atom <: andornafnegformula = ~(AndOrNafNegFormula <: atom) }
fact AtleastQuantifiedFormula_atleastquantifiedformula_atleastandatmostquantifiedformula_AtLeastAndAtMostQuantifiedFormula_symmetry { AtLeastAndAtMostQuantifiedFormula <: atleastquantifiedformula = ~(AtleastQuantifiedFormula <: atleastandatmostquantifiedformula) }
fact AssoCustom_Conjunction_conjunction_logicalformula_LogicalFormula { all var: Conjunction | # var . logicalformula >= 2 }
fact AssoCustom_AndOrNafNegFormula_andornafnegformula_conjunction_Conjunction { all var: Conjunction | # var . andornafnegformula >= 2 }
fact AssoCustom_Disjunction_disjunction_andornafnegformula_AndOrNafNegFormula { all var: Disjunction | # var . andornafnegformula >= 2 }
fact AssoCustom_EqualityAtom_equalityatom_objectterm_ObjectTerm { all var: EqualityAtom | # var . objectterm >= 2 }
fact AssoCustom_ObjectTerm_objectterm_inequalityatom_InequalityAtom { all var: InequalityAtom | # var . objectterm >= 2 }
fact AssoCustom_AssociationAtom_associationatom_objectterm_ObjectTerm { all var: AssociationAtom | # var . objectterm >= 2 }
fact AssoCustom_AndNotEventExpression_andnoteventexpression_eventexpression_EventExpression { all var: AndNotEventExpression | # var . eventexpression = 2 }
fact AssoCustom_EventExpression_eventexpression_sequenceeventexpression_SequenceEventExpression { all var: SequenceEventExpression | # var . eventexpression >= 2 }
fact AssoCustom_ParallelEventExpression_paralleleventexpression_eventexpression_EventExpression { all var: ParallelEventExpression | # var . eventexpression >= 2 }
fact AssoCustom_AssociationPredicate_associationpredicate_type_Type { all var: AssociationPredicate | # var . type >= 2 }
pred Vocabulary_voca1[]{
all p: Vocabulary | some a: RuleSet | p in a.rp5
} 

pred Vocabulary_voca2[]{
all p: Vocabulary | all a1, a2: RuleSet | (
(p in a1.rp5) &&
(p in a2.rp5))
 => 
 (
a1 = a2
)
} 

pred Vocabulary_voca21[]{
all p: Vocabulary | some a: RuleBase | p in a.rp32
} 

pred Vocabulary_voca22[]{
all p: Vocabulary | all a1, a2: RuleBase | (
(p in a1.rp32) &&
(p in a2.rp32))
 => 
 (
a1 = a2
)
} 

pred RuleSet_rule1[]{
all p: RuleSet | some a: RuleBase | p in a.rp31
} 

pred RuleSet_rule2[]{
all p: RuleSet | all a1, a2: RuleBase | (
(p in a1.rp31) &&
(p in a2.rp31))
 => 
 (
a1 = a2
)
} 

pred ReactionRule_reac1[]{
all p: ReactionRule | some a: ReactionRuleSet | p in a.rp4
} 

pred ReactionRule_reac2[]{
all p: ReactionRule | all a1, a2: ReactionRuleSet | (
(p in a1.rp4) &&
(p in a2.rp4))
 => 
 (
a1 = a2
)
} 

pred ProductionRule_prod1[]{
all p: ProductionRule | some a: ProductionRuleSet | p in a.rp3
} 

pred ProductionRule_prod2[]{
all p: ProductionRule | all a1, a2: ProductionRuleSet | (
(p in a1.rp3) &&
(p in a2.rp3))
 => 
 (
a1 = a2
)
} 

pred DerivationRule_deriv1[]{
all p: DerivationRule | some a: DerivationRuleSet | p in a.rp2
} 

pred DerivationRule_deriv2[]{
all p: DerivationRule | all a1, a2: DerivationRuleSet | (
(p in a1.rp2) &&
(p in a2.rp2))
 => 
 (
a1 = a2
)
} 

pred IntegrityRule_integ1[]{
all p: IntegrityRule | some a: IntegrityRuleSet | p in a.rp
} 

pred IntegrityRule_integ2[]{
all p: IntegrityRule | all a1, a2: IntegrityRuleSet | (
(p in a1.rp) &&
(p in a2.rp))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi1[]{
all p: LogicalFormula | some a: StrongNegation | p in a.rp21
} 

pred LogicalFormula_logi2[]{
all p: LogicalFormula | all a1, a2: StrongNegation | (
(p in a1.rp21) &&
(p in a2.rp21))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi21[]{
all p: LogicalFormula | some a: Implication | p in a.rp22
} 

pred LogicalFormula_logi22[]{
all p: LogicalFormula | all a1, a2: Implication | (
(p in a1.rp22) &&
(p in a2.rp22))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi31[]{
all p: LogicalFormula | some a: Implication | p in a.rp23
} 

pred LogicalFormula_logi32[]{
all p: LogicalFormula | all a1, a2: Implication | (
(p in a1.rp23) &&
(p in a2.rp23))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi41[]{
all p: LogicalFormula | some a: NegationAsFailure | p in a.rp24
} 

pred LogicalFormula_logi42[]{
all p: LogicalFormula | all a1, a2: NegationAsFailure | (
(p in a1.rp24) &&
(p in a2.rp24))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi51[]{
all p: LogicalFormula | some a: Disjunction | p in a.rp25
} 

pred LogicalFormula_logi52[]{
all p: LogicalFormula | all a1, a2: Disjunction | (
(p in a1.rp25) &&
(p in a2.rp25))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi61[]{
all p: LogicalFormula | some a: Conjunction | p in a.rp26
} 

pred LogicalFormula_logi62[]{
all p: LogicalFormula | all a1, a2: Conjunction | (
(p in a1.rp26) &&
(p in a2.rp26))
 => 
 (
a1 = a2
)
} 

pred LogicalFormula_logi71[]{
all p: LogicalFormula | some a: QuantifiedFormula | p in a.rp27
} 

pred LogicalFormula_logi72[]{
all p: LogicalFormula | all a1, a2: QuantifiedFormula | (
(p in a1.rp27) &&
(p in a2.rp27))
 => 
 (
a1 = a2
)
} 

pred AndOrNafNegFormula_andor1[]{
all p: AndOrNafNegFormula | some a: Conjunction | p in a.rp8
} 

pred AndOrNafNegFormula_andor2[]{
all p: AndOrNafNegFormula | all a1, a2: Conjunction | (
(p in a1.rp8) &&
(p in a2.rp8))
 => 
 (
a1 = a2
)
} 

pred AndOrNafNegFormula_andor11[]{
all p: AndOrNafNegFormula | some a: Disjunction | p in a.rp7
} 

pred AndOrNafNegFormula_andor12[]{
all p: AndOrNafNegFormula | all a1, a2: Disjunction | (
(p in a1.rp7) &&
(p in a2.rp7))
 => 
 (
a1 = a2
)
} 

pred AndOrNafNegFormula_andor21[]{
all p: AndOrNafNegFormula | some a: Negation | p in a.rp6
} 

pred AndOrNafNegFormula_andor22[]{
all p: AndOrNafNegFormula | all a1, a2: Negation | (
(p in a1.rp6) &&
(p in a2.rp6))
 => 
 (
a1 = a2
)
} 

pred AndOrNafNegFormula_andor31[]{
all p: AndOrNafNegFormula | some a: ReactionRule | p in a.postcondition
} 

pred AndOrNafNegFormula_andor32[]{
all p: AndOrNafNegFormula | all a1, a2: ReactionRule | (
(p in a1.postcondition) &&
(p in a2.postcondition))
 => 
 (
a1 = a2
)
} 

pred AndOrNafNegFormula_andor41[]{
all p: AndOrNafNegFormula | some a: ReactionRule | p in a.conditions
} 

pred AndOrNafNegFormula_andor42[]{
all p: AndOrNafNegFormula | all a1, a2: ReactionRule | (
(p in a1.conditions) &&
(p in a2.conditions))
 => 
 (
a1 = a2
)
} 

pred EventExpression_even1[]{
all p: EventExpression | some a: AndNotEventExpression | p in a.rp17
} 

pred EventExpression_even2[]{
all p: EventExpression | all a1, a2: AndNotEventExpression | (
(p in a1.rp17) &&
(p in a2.rp17))
 => 
 (
a1 = a2
)
} 

pred EventExpression_even21[]{
all p: EventExpression | some a: SequenceEventExpression | p in a.rp16
} 

pred EventExpression_even22[]{
all p: EventExpression | all a1, a2: SequenceEventExpression | (
(p in a1.rp16) &&
(p in a2.rp16))
 => 
 (
a1 = a2
)
} 

pred EventExpression_even31[]{
all p: EventExpression | some a: ChoiceEventExpression | p in a.rp18
} 

pred EventExpression_even32[]{
all p: EventExpression | all a1, a2: ChoiceEventExpression | (
(p in a1.rp18) &&
(p in a2.rp18))
 => 
 (
a1 = a2
)
} 

pred EventExpression_even41[]{
all p: EventExpression | some a: ReactionRule | p in a.triggeredEventExpr
} 

pred EventExpression_even42[]{
all p: EventExpression | all a1, a2: ReactionRule | (
(p in a1.triggeredEventExpr) &&
(p in a2.triggeredEventExpr))
 => 
 (
a1 = a2
)
} 

pred EventExpression_event51[]{
all p: EventExpression | some a: ReactionRule | p in a.triggeringEventExpr
} 

pred EventExpression_event52[]{
all p: EventExpression | all a1, a2: ReactionRule | (
(p in a1.tiggeringEventExpr) &&
(p in a2.tiggeringEventExpr))
 => 
 (
a1 = a2
)
} 

pred Conjunction_conjg1[]{
all p1, p2: Conjunction | (
p1 != p2)
 => 
 (
p1.rg11 != p2.rg11
)
} 

pred Disjunction_disjg1[]{
all p1, p2: Disjunction | (
p1 != p2)
 => 
 (
p1.rg9 != p2.rg9
)
} 

pred NegationAsFailure_negag1[]{
all p1, p2: NegationAsFailure | (
p1 != p2)
 => 
 (
p1.rg6 != p2.rg6
)
} 

pred StrongNegation_strog1[]{
all p1, p2: StrongNegation | (
p1 != p2)
 => 
 (
p1.rg2 != p2.rg2
)
} 

pred Atom_atom1[]{
all p: Atom | some a: LiteralConjunction | p in a.rp20
} 

pred Atom_atom2[]{
all p: Atom | all a1, a2: LiteralConjunction | (
(p in a1.rp20) &&
(p in a2.rp20))
 => 
 (
a1 = a2
)
} 

pred Atom_atomg1[]{
all p1, p2: Atom | (
p1 != p2)
 => 
 (
p1.rg12 != p2.rg12
)
} 

pred AtLeastAndAtMostQuantifiedFormula_newConstraint[]{
all p1, p2: AtLeastAndAtMostQuantifiedFormula | (
p1 != p2)
 => 
 (
p1.rg13 != p2.rg13
)
} 

pred ReferencePropertyAtom_refeg1[]{
all p1, p2: ReferencePropertyAtom | (
p1 != p2)
 => 
 (
p1.rg3 != p2.rg3
)
} 

pred ObjectTerm_obje1[]{
all p: ObjectTerm | some a: AttributionAtom | p in a.subject
} 

pred ObjectTerm_obje2[]{
all p: ObjectTerm | all a1, a2: AttributionAtom | (
(p in a1.subject) &&
(p in a2.subject))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje21[]{
all p: ObjectTerm | some a: AttributeFunctionTerm | p in a.rp11
} 

pred ObjectTerm_obje22[]{
all p: ObjectTerm | all a1, a2: AttributeFunctionTerm | (
(p in a1.rp11) &&
(p in a2.rp11))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje31[]{
all p: ObjectTerm | some a: DataOperationTerm | p in a.rp12
} 

pred ObjectTerm_obje32[]{
all p: ObjectTerm | all a1, a2: DataOperationTerm | (
(p in a1.rp12) &&
(p in a2.rp12))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje41[]{
all p: ObjectTerm | some a: InequalityAtom | p in a.rp14
} 

pred ObjectTerm_obje42[]{
all p: ObjectTerm | all a1, a2: InequalityAtom | (
(p in a1.rp14) &&
(p in a2.rp14))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje51[]{
all p: ObjectTerm | some a: EqualityAtom | p in a.rp15
} 

pred ObjectTerm_obje52[]{
all p: ObjectTerm | all a1, a2: EqualityAtom | (
(p in a1.rp15) &&
(p in a2.rp15))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje61[]{
all p: ObjectTerm | some a: ObjectClassificationAtom | p in a.rp28
} 

pred ObjectTerm_obje62[]{
all p: ObjectTerm | all a1, a2: ObjectClassificationAtom | (
(p in a1.rp28) &&
(p in a2.rp28))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje71[]{
all p: ObjectTerm | some a: ReferencePropertyAtom | p in a.rp29
} 

pred ObjectTerm_obje81[]{
all p: ObjectTerm | some a: ReferencePropertyAtom | p in a.rp30
} 

pred ObjectTerm_obje72[]{
all p: ObjectTerm | all a1, a2: ReferencePropertyAtom | (
(p in a1.rp29) &&
(p in a2.rp29))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje82[]{
all p: ObjectTerm | all a1, a2: ReferencePropertyAtom | (
(p in a1.rp30) &&
(p in a2.rp30))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje91[]{
all p: ObjectTerm | some a: UpdateActionExpr | p in a.rp37
} 

pred ObjectTerm_obje92[]{
all p: ObjectTerm | all a1, a2: UpdateActionExpr | (
(p in a1.rp37) &&
(p in a2.rp37))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje101[]{
all p: ObjectTerm | some a: InvokeActionExpression | p in a.rp38
} 

pred ObjectTerm_obje102[]{
all p: ObjectTerm | all a1, a2: InvokeActionExpression | (
(p in a1.rp38) &&
(p in a2.rp38))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje111[]{
all p: ObjectTerm | some a: AssertActionExpression | p in a.rp39
} 

pred ObjectTerm_obje112[]{
all p: ObjectTerm | all a1, a2: AssertActionExpression | (
(p in a1.rp39) &&
(p in a2.rp39))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje121[]{
all p: ObjectTerm | some a: RetractActionExpression | p in a.rp40
} 

pred ObjectTerm_obje122[]{
all p: ObjectTerm | all a1, a2: RetractActionExpression | (
(p in a1.rp40) &&
(p in a2.rp40))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje131[]{
all p: ObjectTerm | some a: ReferencePropertyFunctionTerm | p in a.rp42
} 

pred ObjectTerm_obje132[]{
all p: ObjectTerm | all a1, a2: ReferencePropertyFunctionTerm | (
(p in a1.rp42) &&
(p in a2.rp42))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje141[]{
all p: ObjectTerm | some a: ObjectOperationTerm | p in a.rp43
} 

pred ObjectTerm_obje142[]{
all p: ObjectTerm | all a1, a2: ObjectOperationTerm | (
(p in a1.rp43) &&
(p in a2.rp43))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje151[]{
all p: ObjectTerm | some a: ObjectDescriptionAtom | p in a.subject
} 

pred ObjectTerm_obje152[]{
all p: ObjectTerm | all a1, a2: ObjectDescriptionAtom | (
(p in a1.subject) &&
(p in a2.subject))
 => 
 (
a1 = a2
)
} 

pred ObjectTerm_obje161[]{
all p: ObjectTerm | some a: ObjectSlot | p in a.object
} 

pred ObjectTerm_obje162[]{
all p: ObjectTerm | all a1, a2: ObjectSlot | (
(p in a1.object) &&
(p in a2.object))
 => 
 (
a1 = a2
)
} 

pred DataTerm_data1[]{
all p: DataTerm | some a: AttributionAtom | p in a.dataValue
} 

pred DataTerm_data2[]{
all p: DataTerm | all a1, a2: AttributionAtom | (
(p in a1.dataValue) &&
(p in a2.dataValue))
 => 
 (
a1 = a2
)
} 

pred DataTerm_data21[]{
all p: DataTerm | some a: DataClassificationAtom | p in a.rp9
} 

pred DataTerm_data22[]{
all p: DataTerm | all a1, a2: DataClassificationAtom | (
(p in a1.rp9) &&
(p in a2.rp9))
 => 
 (
a1 = a2
)
} 

pred DataTerm_data31[]{
all p: DataTerm | some a: DataTypeFuncionTerm | p in a.rp10
} 

pred DataTerm_data32[]{
all p: DataTerm | all a1, a2: DataTypeFuncionTerm | (
(p in a1.rp10) &&
(p in a2.rp10))
 => 
 (
a1 = a2
)
} 

pred DataTerm_data41[]{
all p: DataTerm | some a: DatatypePredicateAtom | p in a.rp13
} 

pred DataTerm_data42[]{
all p: DataTerm | all a1, a2: DatatypePredicateAtom | (
(p in a1.rp13) &&
(p in a2.rp13))
 => 
 (
a1 = a2
)
} 

pred DataTerm_data51[]{
all p: DataTerm | some a: DataSlot | p in a.value
} 

pred DataTerm_data52[]{
all p: DataTerm | all a1, a2: DataSlot | (
(p in a1.value) &&
(p in a2.value))
 => 
 (
a1 = a2
)
} 

pred Slot_slot1[]{
all p: Slot | some a: AtomicEventExpression | p in a.rp19
} 

pred Slot_slot2[]{
all p: Slot | all a1, a2: AtomicEventExpression | (
(p in a1.rp19) &&
(p in a2.rp19))
 => 
 (
a1 = a2
)
} 

pred Slot_slot21[]{
all p: Slot | some a: AssertActionExpression | p in a.rp41
} 

pred Slot_slot22[]{
all p: Slot | all a1, a2: AssertActionExpression | (
(p in a1.rp41) &&
(p in a2.rp41))
 => 
 (
a1 = a2
)
} 

pred Slot_slot31[]{
all p: Slot | some a: ObjectDescriptionAtom | p in a.rp45
} 

pred Slot_slot32[]{
all p: Slot | all a1, a2: ObjectDescriptionAtom | (
(p in a1.rp45) &&
(p in a2.rp45))
 => 
 (
a1 = a2
)
} 

pred Term_term1[]{
all p: Term | some a: InvokeActionExpression | p in a.rp35
} 

pred Term_term2[]{
all p: Term | all a1, a2: InvokeActionExpression | (
(p in a1.rp35) &&
(p in a2.rp35))
 => 
 (
a1 = a2
)
} 

pred Term_term21[]{
all p: Term | some a: UpdateActionExpr | p in a.rp36
} 

pred Term_term22[]{
all p: Term | all a1, a2: UpdateActionExpr | (
(p in a1.rp36) &&
(p in a2.rp36))
 => 
 (
a1 = a2
)
} 

pred Term_term31[]{
all p: Term | some a: ObjectOperationTerm | p in a.rp44
} 

pred Term_term32[]{
all p: Term | all a1, a2: ObjectOperationTerm | (
(p in a1.rp44) &&
(p in a2.rp44))
 => 
 (
a1 = a2
)
} 

pred DataVariable_datag1[]{
all p1, p2: DataVariable | (
p1 != p2)
 => 
 (
p1.rg10 != p2.rg10
)
} 

pred GenericVariable_newConstraint[]{
all p1, p2: GenericVariable | (
p1 != p2)
 => 
 (
p1.rg7 != p2.rg7
)
} 

pred ObjectVariable_objeg1[]{
all p1, p2: ObjectVariable | (
p1 != p2)
 => 
 (
p1.rg4 != p2.rg4
)
} 

pred ObjectName_objeg1[]{
all p1, p2: ObjectName | (
p1 != p2)
 => 
 (
p1.rg5 != p2.rg5
)
} 
pred DataLiteral_data1[]{
all p: DataLiteral | some a: EnumerationDatatype | p in a.rp33
} 
pred DataLiteral_data2[]{
all p: DataLiteral | all a1, a2: EnumerationDatatype | (
(p in a1.rp33) &&
(p in a2.rp33))
 => 
 (
a1 = a2
)
} 
pred GenericEntityName_geneg1[]{
all p1, p2: GenericEntityName | (
p1 != p2)
 => 
 (
p1.rg8 != p2.rg8
)
} 
pred Property_propg1[]{
all p1, p2: Property | (
p1 != p2)
 => 
 (
p1.rg != p2.rg
)
} 

pred VocabularyEntery_voca1[]{
all p: VocabularyEntery | some a: Vocabulary | p in a.rp34
} 

pred VocabularyEntery_voca2[]{
all p: VocabularyEntery | all a1, a2: Vocabulary | (
(p in a1.rp34) &&
(p in a2.rp34))
 => 
 (
a1 = a2
)
} 

run {} for 4 but 2 int