Index: /reasoner/reasoner.tex
===================================================================
--- /reasoner/reasoner.tex	(revision 57)
+++ /reasoner/reasoner.tex	(revision 58)
@@ -422,5 +422,5 @@
 In more detail, Algorithm \ref{algTranslateDeclaration} first declares some local variables in line \ref{algTranslateDeclarationDecl}, including the actual type $t$ (to be overridden by the type of the default value expression if needed), the default value expression $dflt$, the actual set of default constraints ($\defaultConstraints$ or $\deferredDefaultConstraints$) to be utilized for adding the final constraint and the actual value of self $s$ (for compound types only). Then, if $t$ is a derived data type, constraints are translated and collected through Algorithm \ref{algTranslateDerivedDatatypeConstraints}. In non-incremental mode, i.e., we translate default value expressions to assignment constraints as well as the default constraints for annotations can then be translated using \ref{algTranslateAnnotationDefaults}. Due to potential type interferences with derived types, we determine then the actual type through the type of the default value expression if defined. If $t$ is a compound type, we set the value of self $v$ to the actual variable declaration $d$ and execute the specific translations for compound types using Algorithm \ref{algTranslateCompoundDeclaration}. If $t$ is a container type, we call \ref{algTranslateContainerDeclaration} instead. Otherwise, if there is a default value expression and reasoning is not in incremental mode, i.e., we shall translate default value expressions to assignment constraints, and if there is a compound accessor, we just have to schedule a replacement of \IVML{self} by the compound accessor. Remaining default constraints are taken over as defined as long as the reasoner is not operating incremental mode as there no default value assignments are needed.
 
-If there is finally a default value expression to be recorded in the constraint base, we have to distinguish whether the actual variable is a usual or a constraint variable. In the first case, we turn the default value expression into an assignment expression, through the compound accessor if it currently represents \IVML{self}, the variable else. Then, we substitute \IVML{self} and the actual variable mapping on the default value expression. The actual variable is a constraint variable, we can just \TBD{ca??} turn the default value into a constraint, add it to the set of other constraints $\otherConstraints$ and register the relevant variables for the new constraint and the causing variable $v$. For usual variables, turn the already created value assignment expression in $dflt$ into a default constraint and add it either to $\deferredDefaultConstraints$ the constraint may override a complete value assignment (\IVML{self} is used or $d$ is an overridden slot) or to the usual default constraints set $\defaultConstraints$.
+If there is finally a default value expression to be recorded in the constraint base, we have to distinguish whether the actual variable is a usual or a constraint variable. In the first case, we turn the default value expression into an assignment expression, through the compound accessor if it currently represents \IVML{self}, the variable else. Then, we substitute \IVML{self} and the actual variable mapping on the default value expression. The actual variable is a constraint variable, we can just turn the default value into a constraint, add it to the set of other constraints $\otherConstraints$ and register the relevant variables for the new constraint and the causing variable $v$. For usual variables, turn the already created value assignment expression in $dflt$ into a default constraint and add it either to $\deferredDefaultConstraints$ the constraint may override a complete value assignment (\IVML{self} is used or $d$ is an overridden slot) or to the usual default constraints set $\defaultConstraints$.
 
 \begin{algorithm}[H]
@@ -449,8 +449,8 @@
           $dflt \assng \varSubstitutionSelfVarMapping{dflt}{s}$\;
           \uIf{$isConstraint(type(d))$}{
-              \If{$ ca == \undef $ \TBD{really needed???}}{
+              %\If{$ ca == \undef $ \TBD{really needed???}}{
                   $add(\otherConstraints, \createConstraint{dflt}, true)$\;
                   $\relevantConstraints \assng \relevantConstraints \addMap \mapEntry{\createConstraint{dflt}}{v}$
-               }
+               %}
           }\Else{ 
              \lIf{$\IVMLself{} \in dflt \vee isOverridenSlot(d)$}{$dfltS \assng \deferredDefaultConstraints$}\lElse{$dfltS \assng \defaultConstraints$}
@@ -561,5 +561,7 @@
 First, Algorithm \ref{algTranslateCompoundDeclaration} creates all accessors for all slots of the compound and registers them in the variable mapping $\variableMapping$. While the first case creates a static accessor based on the declared type, the second case mitigates the problem that on slots known for specific value types may not be accessed through simple accessor expression as the compound access may be created for a refined type. Therefore, it creates a compound accessor for the most specific type obtained from an IVML type cast of the compound accessor to the actual value type (can be omitted if $t=type(value(v))$, not shown here). Then, it performs a transitive translation of the default values of all slots using the respective accessor calling Algorithm \ref{algTranslateDeclaration}.
 
-Second, Algorithm \ref{algTranslateCompoundDeclaration} considers all slots, in particular if one slot is a container of constraints, it translates all (constraint) values into instantiated constraints by substituting \IVMLself{} with the actual declaration (including matching mappings in $\variableMapping$) adding the translated constraint to the set of constraint variables ($\otherConstraints$). If the slot directly represents a constraint (variable), the algorithm performs a similar translation on the respective default value expression. If the slot is a compound container, it translates all (\TBD{defaults?}) the contained constraints using Algorithm \ref{algTranslateContainerCompoundConstraints}. 
+Second, Algorithm \ref{algTranslateCompoundDeclaration} considers all slots, in particular if one slot is a container of constraints, it translates all (constraint) values into instantiated constraints by substituting \IVMLself{} with the actual declaration (including matching mappings in $\variableMapping$) adding the translated constraint to the set of constraint variables ($\otherConstraints$). 
+%If the slot directly represents a constraint (variable), the algorithm performs a similar translation on the respective default value expression. 
+If the slot is a compound container, it translates all (\TBD{defaults?}) the contained constraints using Algorithm \ref{algTranslateContainerCompoundConstraints}. 
 
 Finally, the algorithm translates all attribute assignments using Algorithm \ref{algTranslateAnnotationAssignments}, all direct compound constraints (substituting \IVMLself{} and registered variables), and translates and collects all eval constraints (\TBD{no self??}).
@@ -581,7 +583,7 @@
           $add(\otherConstraints, \setWith{\createConstraint{\varSubstitutionSelfVarMapping{value(e)}{d}}}{e \in elements(value(s))}, true)$\;
       }
-      \If{$isConstraint(type(s)) \wedge default(s) \neq \undef$}{
-          $add(\otherConstraints, \set{\createConstraint{\varSubstitutionSelfVarMapping{default(s)}{d}}}, true)$\;
-      }
+      %\If{$isConstraint(type(s)) \wedge default(s) \neq \undef$}{
+      %    $add(\otherConstraints, \set{\createConstraint{\varSubstitutionSelfVarMapping{default(s)}{d}}}, true)$\;
+      %}
       \If{$isContainer(type(s))$} {
      $add(\otherConstraints, translateContainerCompoundConstraints(s, v, \variableMapping[s]), true)$\;