Table of Contents 
    
    
    
    
    
      
        
          Target Namespace 
         
        None 
       
      
        Element and Attribute Namespaces 
        
          
            Global element and attribute declarations belong to this schema's target namespace. 
            By default, local element declarations belong to this schema's target namespace. 
            By default, local attribute declarations have no namespace. 
           
         
       
    
    Declared Namespaces 
    
      
        Prefix 
        Namespace 
       
      
        
          xml 
         
        http://www.w3.org/XML/1998/namespace 
       
      
        
          xs 
         
        http://www.w3.org/2001/XMLSchema 
       
    
    
      Schema Component Representation 
      
        <
xs:schema  elementFormDefault ="
qualified ">
...
</
xs:schema >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      XML Instance Representation 
      
        <Adjective
 nr="xs :integer[1] "  value="xs :boolean[0..1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] "  kind="xs :tokenvalue  comes from list: {'V'})[0..1] "  pid="xs :integer[0..1] " > 
</Adjective>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Adjective ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
value " 
type ="
xs :boolean"/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
kind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="V "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: And  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <And
 pid="xs :integer[0..1] " > 
</And>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
And " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Formula " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ArgTypes ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Article
 aid="xs :string[1] " > 
Start Choice  [0..*]  Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </Article>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Article ">
<
xs:complexType >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
</
xs:choice >
<
xs:attribute  name ="
aid " 
type ="
xs :string" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <ArticleID
 name="xs :string[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
ArticleID ">
<
xs:complexType >
<
xs:attribute  name ="
name " 
type ="
xs :string" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Assume ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <BlockThesis> 
</BlockThesis>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
BlockThesis ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: By  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <By
 line="xs :integer[1] "  col="xs :integer[1] "  linked="xs :boolean[0..1] " > 
</By>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
By " 
substitutionGroup ="
Inference ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Ref " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
linked " 
type ="
xs :boolean"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <ByExplanations
 aid="xs :string[1] " > 
</ByExplanations>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
ByExplanations ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
PolyEval " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <CCluster
 nr="xs :integer[0..1] "  aid="xs :string[0..1] " > 
Start Choice  [1]  End Choice </CCluster>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
CCluster ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Canceled ">
<xs:complexType />
</
xs:element >
 
      
     
    
    Element: Case  
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Case ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <CaseBlock
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [1]  Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice End Choice </CaseBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
CaseBlock ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Cluster ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Adjective " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ComplexNr " 
substitutionGroup ="
Number ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Conclusion> 
Start Choice  [1]  End Choice </Conclusion>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Conclusion ">
<
xs:complexType >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      XML Instance Representation 
      
        <Consider
 nr="xs :integer[0..1] " > 
</Consider>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Consider ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
Proposition " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Const
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Const " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <ConstrCount
 kind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'})[1] "  nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
ConstrCount ">
<
xs:complexType >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <ConstrCounts
 name="xs :string[0..1] " > 
</ConstrCounts>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
ConstrCounts ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
ConstrCount " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
name " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Constructor
 kind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'})[1] "  nr="xs :integer[1] "  aid="xs :string[1] "  relnr="xs :integer[0..1] "  redefnr="xs :integer[0..1] "  superfluous="xs :integer[0..1] "  absredefnr="xs :integer[0..1] "  redefaid="xs :string[0..1] "  structmodeaggrnr="xs :integer[0..1] "  aggregbase="xs :integer[0..1] " > 
</Constructor>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Constructor ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
Fields " 
minOccurs ="
0 "/>
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
aid " 
type ="
xs :string" 
use ="
required "/>
<
xs:attribute  name ="
relnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
redefnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
superfluous " 
type ="
xs :integer"/>
<
xs:attribute  name ="
absredefnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
redefaid " 
type ="
xs :string"/>
<
xs:attribute  name ="
structmodeaggrnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aggregbase " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Constructors
 aid="xs :string[0..1] " > 
Start Choice  [0..1]  End Choice </Constructors>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Constructors ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  minOccurs ="
0 ">
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
<
xs:element  ref ="
Constructor " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Correctness> 
</Correctness>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Correctness ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
      
        Name 
        CorrectnessCondition 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        yes 
       
    
    
      XML Instance Representation 
      
        <CorrectnessCondition> 
Start Choice  [1]  End Choice </CorrectnessCondition>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
CorrectnessCondition " 
abstract ="
true ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <DefFunc
 nr="xs :integer[0..1] " > 
</DefFunc>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
DefFunc ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <DefMeaning
 kind="xs :tokenvalue  comes from list: {'e'|'m'})[1] " > 
Start Choice  [0..1]  End Choice </DefMeaning>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
DefMeaning ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
PartialDef " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:choice  minOccurs ="
0 ">
</
xs:choice >
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="e "/>
<xs:enumeration  value ="m "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <DefPred
 nr="xs :integer[0..1] " > 
</DefPred>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
DefPred ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <DefTheorem
 constrkind="xs :tokenvalue  comes from list: {'M'|'V'|'R'|'K'})[0..1] "  constrnr="xs :integer[0..1] " > 
</DefTheorem>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
DefTheorem ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
constrkind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
constrnr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Definiens
 constrkind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'})[1] "  constrnr="xs :integer[1] "  defnr="xs :integer[1] "  aid="xs :string[1] "  nr="xs :integer[0..1] "  relnr="xs :integer[0..1] " > 
</Definiens>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Definiens ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
Formula " 
minOccurs ="
0 "/>
</
xs:sequence >
<
xs:attribute  name ="
constrkind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
constrnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
defnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
aid " 
type ="
xs :string" 
use ="
required "/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
relnr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Definientia
 aid="xs :string[0..1] " > 
</Definientia>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Definientia ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Definiens " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Definition
 kind="xs :tokenvalue  comes from list: {'M'|'V'|'R'|'K'|'G'})[1] "  redefinition="xs :boolean[0..1] "  expandable="xs :boolean[0..1] "  nr="xs :integer[0..1] "  line="xs :integer[0..1] "  col="xs :integer[0..1] " > 
Start Choice  [1]  End Choice </Definition>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Definition ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
<
xs:element  ref ="
Pattern " 
minOccurs ="
0 "/>
</
xs:sequence >
<
xs:sequence >
<
xs:element  ref ="
Pattern " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:choice >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="G "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
redefinition " 
type ="
xs :boolean"/>
<
xs:attribute  name ="
expandable " 
type ="
xs :boolean"/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
line " 
type ="
xs :integer"/>
<
xs:attribute  name ="
col " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <DefinitionBlock
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [0..*]  Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </DefinitionBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
DefinitionBlock ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
<
xs:element  ref ="
Given "/>
</
xs:choice >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <EndPosition
 line="xs :integer[1] "  col="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
EndPosition ">
<
xs:complexType >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ErrorCluster ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ErrorFrm " 
substitutionGroup ="
Formula ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ErrorInf " 
substitutionGroup ="
Inference ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
ErrorTrm " 
substitutionGroup ="
Term ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Essentials> 
</Essentials>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Essentials ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Int " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Expansion ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <FCluster
 nr="xs :integer[0..1] "  aid="xs :string[0..1] " > 
Start Choice  [1]  End Choice </FCluster>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
FCluster ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
minOccurs ="
0 "/>
</
xs:sequence >
</
xs:choice >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Field
 nr="xs :integer[1] "  kind="xs :tokenvalue  comes from list: {'U'})[0..1] "  aid="xs :string[0..1] "  absnr="xs :integer[0..1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Field ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
kind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="U "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Fields ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Field " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: For  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <For
 pid="xs :integer[0..1] " > 
</For>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
For " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Format
 kind="xs :tokenvalue  comes from list: {'G'|'K'|'J'|'L'|'M'|'O'|'R'|'U'|'V'})[1] "  nr="xs :integer[0..1] "  symbolnr="xs :integer[1] "  argnr="xs :integer[1] "  leftargnr="xs :integer[0..1] "  rightsymbolnr="xs :integer[0..1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Format ">
<
xs:complexType >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="J "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="O "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="V "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
symbolnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
argnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
leftargnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
rightsymbolnr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Formats ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Format " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
Priority " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Fraenkel " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <FreeVar
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
FreeVar " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: From  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <From
 line="xs :integer[1] "  col="xs :integer[1] "  articlenr="xs :integer[1] "  nr="xs :integer[1] " > 
</From>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
From " 
substitutionGroup ="
Inference ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Ref " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
articlenr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <FromExplanations
 aid="xs :string[1] " > 
</FromExplanations>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
FromExplanations ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Func  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Func
 kind="xs :tokenvalue  comes from list: {'F'|'G'|'K'|'U'})[1] "  nr="xs :integer[1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] "  pid="xs :integer[0..1] " > 
</Func>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Func " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="F "/>
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <FuncInstance
 instnr="xs :integer[1] "  kind="xs :tokenvalue  comes from list: {'F'|'H'|'G'|'K'|'U'})[0..1] "  nr="xs :integer[0..1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] " > 
</FuncInstance>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
FuncInstance ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
minOccurs ="
0 "/>
</
xs:sequence >
<
xs:attribute  name ="
instnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
kind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="F "/>
<xs:enumeration  value ="H "/>
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      XML Instance Representation 
      
        <Given
 nr="xs :integer[0..1] " > 
</Given>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Given ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <InfConst
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
InfConst " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Int  
    
    
      XML Instance Representation 
      
        <Int
 x="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Int ">
<
xs:complexType >
<
xs:attribute  name ="
x " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Is  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Is " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: It  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
It " 
substitutionGroup ="
Term ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <IterEquality
 nr="xs :integer[0..1] "  line="xs :integer[1] "  col="xs :integer[1] " > 
</IterEquality>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
IterEquality ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
IterStep " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
IterStep ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
      
        Name 
        Justification 
       
      
        Type 
        anyType 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        yes 
       
      
        Documentation 
        Direct justification.    
       
    
    
    
    
    
      
        Name 
        JustifiedProperty 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        no 
       
    
    
      XML Instance Representation 
      
        <JustifiedProperty> 
</JustifiedProperty>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
JustifiedProperty ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <JustifiedTheorem> 
</JustifiedTheorem>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
JustifiedTheorem ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <LambdaVar
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
LambdaVar " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Let  
    
    
      XML Instance Representation 
      
        <Let
 nr="xs :integer[0..1] " > 
</Let>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Let ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Typ " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <LocusVar
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
LocusVar " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Monomial ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
PoweredVar " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Not  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Not
 pid="xs :integer[0..1] " > 
</Not>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Not " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <NotationBlock
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [0..*]  Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </NotationBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
NotationBlock ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
</
xs:choice >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Notations
 aid="xs :string[0..1] " > 
Start Sequence  [0..1]  End Sequence </Notations>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Notations ">
<
xs:complexType >
<
xs:sequence >
<
xs:sequence  minOccurs ="
0 ">
</
xs:sequence >
<
xs:element  ref ="
Pattern " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Now  
    
    
      XML Instance Representation 
      
        <Now
 nr="xs :integer[0..1] "  line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </Now>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Now ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Num  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Num
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Num " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Pair  
    
    
      XML Instance Representation 
      
        <Pair
 x="xs :integer[1] "  y="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Pair ">
<
xs:complexType >
<
xs:attribute  name ="
x " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
y " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <PartialDef> 
Start Choice  [1]  End Choice </PartialDef>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PartialDef ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Pattern
 kind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'|'J'})[1] "  nr="xs :integer[0..1] "  aid="xs :string[0..1] "  formatnr="xs :integer[0..1] "  constrkind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'|'J'})[1] "  constrnr="xs :integer[1] "  antonymic="xs :boolean[0..1] "  relnr="xs :integer[0..1] "  redefnr="xs :integer[0..1] " > 
</Pattern>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Pattern ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Format " 
minOccurs ="
0 "/>
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="J "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
formatnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
constrkind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="J "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
constrnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
antonymic " 
type ="
xs :boolean"/>
<
xs:attribute  name ="
relnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
redefnr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
PerCases ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        Name 
        PerCasesReasoning 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        no 
       
    
    
      XML Instance Representation 
      
        <PerCasesReasoning
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [1]  Start Choice  [1]  End Choice Start Choice  [1]  End Choice End Choice </PerCasesReasoning>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PerCasesReasoning ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
<
xs:choice >
<
xs:element  ref ="
CaseBlock " 
maxOccurs ="
unbounded "/>
</
xs:choice >
</
xs:sequence >
<
xs:sequence >
<
xs:choice >
<
xs:element  ref ="
CaseBlock " 
maxOccurs ="
unbounded "/>
</
xs:choice >
</
xs:sequence >
</
xs:choice >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <PolyEval
 line="xs :integer[1] "  col="xs :integer[1] "  value="xs :boolean[0..1] " > 
</PolyEval>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PolyEval ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
value " 
type ="
xs :boolean"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Polynomial> 
</Polynomial>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Polynomial " 
substitutionGroup ="
GeneralPolynomial ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Monomial " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <PoweredVar
 nr="xs :integer[1] "  exponent="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PoweredVar ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
exponent " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Pred  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Pred
 kind="xs :tokenvalue  comes from list: {'P'|'V'|'R'})[1] "  nr="xs :integer[1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] "  pid="xs :integer[0..1] " > 
</Pred>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Pred " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="P "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <PredInstance
 instnr="xs :integer[1] "  kind="xs :tokenvalue  comes from list: {'P'|'S'|'V'|'R'})[1] "  nr="xs :integer[1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PredInstance ">
<
xs:complexType >
<
xs:attribute  name ="
instnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="P "/>
<xs:enumeration  value ="S "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Priority
 kind="xs :tokenvalue  comes from list: {'O'|'K'|'L'})[1] "  symbolnr="xs :integer[1] "  value="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Priority ">
<
xs:complexType >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="O "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="L "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
symbolnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
value " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <PrivFunc
 nr="xs :integer[1] " > 
</PrivFunc>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PrivFunc " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <PrivPred
 nr="xs :integer[1] " > 
</PrivPred>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
PrivPred " 
substitutionGroup ="
Formula ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Proof
 nr="xs :integer[0..1] "  line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </Proof>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Proof " 
substitutionGroup ="
Justification ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Properties
 propertyarg1="xs :integer[1] "  propertyarg2="xs :integer[1] " > 
</Properties>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Properties ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Property " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
propertyarg1 " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
propertyarg2 " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Property " 
abstract ="
true ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Proposition
 line="xs :integer[1] "  col="xs :integer[1] "  nr="xs :integer[0..1] " > 
</Proposition>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Proposition ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
QuaTrm " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <RCluster
 nr="xs :integer[0..1] "  aid="xs :string[0..1] " > 
Start Choice  [1]  End Choice </RCluster>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
RCluster ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <RationalNr
 numerator="xs :integer[1] "  denominator="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
RationalNr " 
substitutionGroup ="
Number ">
<
xs:complexType >
<
xs:attribute  name ="
numerator " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
denominator " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Reconsider
 nr="xs :integer[0..1] " > 
</Reconsider>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Reconsider ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Term " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Ref  
    
    
      XML Instance Representation 
      
        <Ref
 nr="xs :integer[1] "  articlenr="xs :integer[0..1] "  kind="xs :tokenvalue  comes from list: {'T'|'D'})[0..1] "  line="xs :integer[1] "  col="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Ref ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
articlenr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
kind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="T "/>
<xs:enumeration  value ="D "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      XML Instance Representation 
      
        <Registration> 
Start Choice  [1]  End Choice </Registration>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Registration ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        Name 
        RegistrationBlock 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        no 
       
    
    
      XML Instance Representation 
      
        <RegistrationBlock
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [1..*]  Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice </RegistrationBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
RegistrationBlock ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  maxOccurs ="
unbounded ">
</
xs:choice >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Registrations
 aid="xs :string[0..1] " > 
Start Choice  [0..*]  End Choice </Registrations>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Registrations ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
</
xs:choice >
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Requirement
 constrkind="xs :tokenvalue  comes from list: {'M'|'L'|'V'|'R'|'K'|'U'|'G'})[1] "  constrnr="xs :integer[1] "  nr="xs :integer[1] "  reqname="xs :string[0..1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Requirement ">
<
xs:complexType >
<
xs:attribute  name ="
constrkind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="G "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
constrnr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
reqname " 
type ="
xs :string"/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Requirements> 
</Requirements>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Requirements ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Requirement " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Reservation> 
</Reservation>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Reservation ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Scheme
 articlenr="xs :integer[0..1] "  nr="xs :integer[0..1] "  aid="xs :string[0..1] " > 
</Scheme>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Scheme ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Formula " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
articlenr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SchemeBlock
 schemenr="xs :integer[1] "  line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [0..*]  End Choice </SchemeBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SchemeBlock ">
<
xs:complexType >
<
xs:sequence >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
</
xs:choice >
</
xs:sequence >
<
xs:attribute  name ="
schemenr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SchemeFuncDecl
 nr="xs :integer[1] " > 
</SchemeFuncDecl>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SchemeFuncDecl ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        Name 
        SchemeInstantiation 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        no 
       
    
    
      XML Instance Representation 
      
        <SchemeInstantiation
 line="xs :integer[1] "  col="xs :integer[1] " > 
</SchemeInstantiation>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SchemeInstantiation ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
FuncInstance " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
PredInstance " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SchemePredDecl
 nr="xs :integer[1] " > 
</SchemePredDecl>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SchemePredDecl ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SchemePremises> 
</SchemePremises>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SchemePremises ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Proposition " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Schemes
 aid="xs :string[0..1] " > 
</Schemes>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Schemes ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Scheme " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Set  
    
    
      XML Instance Representation 
      
        <Set
 nr="xs :integer[0..1] " > 
</Set>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Set ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Signature ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
ArticleID " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        Name 
        SignatureWithCounts 
       
      
        Type 
        Locally-defined complex type 
       
      
        
          Nillable 
         
        no 
       
      
        
          Abstract 
         
        no 
       
    
    
      XML Instance Representation 
      
        <SignatureWithCounts> 
</SignatureWithCounts>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SignatureWithCounts ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
ConstrCounts " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
SkippedProof " 
substitutionGroup ="
Justification ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <StructLoci> 
</StructLoci>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
StructLoci ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Pair " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Suppose ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SupposeBlock
 line="xs :integer[1] "  col="xs :integer[1] " > 
Start Choice  [1]  Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice Start Choice  [0..*]  Start Choice  [1]  End Choice Start Choice  [1]  Start Choice  [1]  End Choice End Choice End Choice End Choice </SupposeBlock>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SupposeBlock ">
<
xs:complexType >
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Symbol
 kind="xs :string[1] "  nr="xs :integer[1] "  name="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Symbol ">
<
xs:complexType >
<
xs:attribute  name ="
kind " 
type ="
xs :string" 
use ="
required "/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
name " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <SymbolCount
 kind="xs :tokenvalue  comes from list: {'G'|'K'|'L'|'M'|'O'|'R'|'U'|'V'})[1] "  nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
SymbolCount ">
<
xs:complexType >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="K "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="O "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="U "/>
<xs:enumeration  value ="V "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Symbols ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Symbol " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Take  
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Take ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <TakeAsVar
 nr="xs :integer[0..1] " > 
</TakeAsVar>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
TakeAsVar ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    Element: Term  
    
      
        
          
            
              The following elements can be used wherever this element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      XML Instance Representation 
      
        <Theorem
 articlenr="xs :integer[0..1] "  nr="xs :integer[0..1] "  constrkind="xs :tokenvalue  comes from list: {'M'|'V'|'R'|'K'})[0..1] "  constrnr="xs :integer[0..1] "  aid="xs :string[0..1] "  kind="xs :tokenvalue  comes from list: {'T'|'D'})[1] " > 
</Theorem>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Theorem ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
<
xs:attribute  name ="
articlenr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
constrkind ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="V "/>
<xs:enumeration  value ="R "/>
<xs:enumeration  value ="K "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
constrnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="T "/>
<xs:enumeration  value ="D "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Theorems
 aid="xs :string[0..1] " > 
</Theorems>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Theorems ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Theorem " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Thesis ">
<
xs:complexType >
<
xs:sequence >
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <ThesisExpansions> 
</ThesisExpansions>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
ThesisExpansions ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Pair " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Typ  
    
    
      XML Instance Representation 
      
        <Typ
 kind="xs :tokenvalue  comes from list: {'M'|'G'|'L'|'errortyp'})[1] "  nr="xs :integer[0..1] "  absnr="xs :integer[0..1] "  aid="xs :string[0..1] "  pid="xs :integer[0..1] " > 
</Typ>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Typ ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Cluster " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
<
xs:element  ref ="
Term " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
<
xs:attribute  name ="
kind " 
use ="
required ">
<
xs:simpleType >
<
xs:restriction  base ="
xs :token">
<xs:enumeration  value ="M "/>
<xs:enumeration  value ="G "/>
<xs:enumeration  value ="L "/>
<xs:enumeration  value ="errortyp "/>
</
xs:restriction >
</
xs:simpleType >
</
xs:attribute >
<
xs:attribute  name ="
nr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
absnr " 
type ="
xs :integer"/>
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
<
xs:attribute  name ="
pid " 
type ="
xs :integer"/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
    
    Element: Var  
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
      XML Instance Representation 
      
        <Var
 nr="xs :integer[1] " /> 
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Var " 
substitutionGroup ="
Term ">
<
xs:complexType >
<
xs:attribute  name ="
nr " 
type ="
xs :integer" 
use ="
required "/>
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      
        
          
            
              This element can be used wherever the following element is referenced: 
              
             
           
         
       
    
    
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Verum " 
substitutionGroup ="
Formula ">
<xs:complexType />
</
xs:element >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:element  name ="
Visible ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Int " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Vocabularies> 
</Vocabularies>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Vocabularies ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
Vocabulary " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    
      XML Instance Representation 
      
        <Vocabulary> 
</Vocabulary>
 
      
     
    
      Schema Component Representation 
      
        <
xs:element  name ="
Vocabulary ">
<
xs:complexType >
<
xs:sequence >
<
xs:element  ref ="
SymbolCount " 
minOccurs ="
0 " 
maxOccurs ="
unbounded "/>
</
xs:sequence >
</
xs:complexType >
</
xs:element >
 
      
     
    
    Attribute Group: Position  
    
    
    
      Schema Component Representation 
      
        <
xs:attributeGroup  name ="
Position ">
<
xs:attribute  name ="
line " 
type ="
xs :integer" 
use ="
required "/>
<
xs:attribute  name ="
col " 
type ="
xs :integer" 
use ="
required "/>
</
xs:attributeGroup >
 
      
     
    
    Attribute Group: Symbols  
    
    
    
      Schema Component Representation 
      
        <
xs:attributeGroup  name ="
Symbols ">
<
xs:attribute  name ="
aid " 
type ="
xs :string"/>
</
xs:attributeGroup >
 
      
     
    
    
      
        Name 
        AuxiliaryItem 
       
      
        Documentation 
        Auxiliary items are items which do not change thesis. 
       
    
    
    
      Schema Component Representation 
      
        <
xs:group  name ="
AuxiliaryItem ">
</
xs:group >
 
      
     
    
    
      
        Name 
        JustifiedProposition 
       
    
    
    
      Schema Component Representation 
      
        <
xs:group  name ="
JustifiedProposition ">
<
xs:choice >
<
xs:sequence >
</
xs:sequence >
</
xs:choice >
</
xs:group >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:group  name ="
Reasoning ">
<
xs:sequence >
<
xs:choice  minOccurs ="
0 " 
maxOccurs ="
unbounded ">
</
xs:choice >
</
xs:sequence >
</
xs:group >
 
      
     
    
    
      Schema Component Representation 
      
        <
xs:group  name ="
SkeletonItem ">
<
xs:sequence >
<
xs:choice >
<
xs:element  ref ="
Given "/>
</
xs:choice >
<
xs:element  ref ="
Thesis " 
minOccurs ="
0 "/>
</
xs:sequence >
</
xs:group >
 
      
     
    
    
      
      
        Complex Type: 
        Schema Component Type
       
      
        
          AusAddress 
         
        Schema Component Name
       
      
        
          Super-types: 
          Address  < AusAddress  (by extension) 
        
          Sub-types: 
          
            
              QLDAddress  (by restriction) 
           
         
      
      If this schema component is a type definition, its type hierarchy is shown in a gray-bordered box.
      
      The table above displays the properties of this schema component.
      
        
          XML Instance Representation 
        
        <...  country="Australia " > 
<unitNo> string  </unitNo> [0..1]  <houseNo> string  </houseNo> [1]  <street> string  </street> [1]  Start Choice [1]  <city> string  </city> [1]  <town> string  </town> [1]  End Choice <state> AusStates  </state> [1]  <postcode> string <<pattern  = [1-9][0-9]{3}>>  </postcode> [1] ?  </...>  
      
        The XML Instance Representation table above shows the schema component's content as an XML instance.
        
          The minimum and maximum occurrence of elements and attributes are provided in square brackets, e.g. [0..1]. 
          Model group information are shown in gray, e.g. Start Choice ... End Choice. 
          For type derivations, the elements and attributes that have been added to or changed from the base type's content are shown in bold . 
          If an element/attribute has a fixed value, the fixed value is shown in green, e.g. country="Australia". 
          Otherwise, the type of the element/attribute is displayed.
               If the element/attribute's type is in the schema, a link is provided to it. For local simple type definitions, the constraints are displayed in angle brackets, e.g. <<pattern  = [1-9][0-9]{3}>>.  
          If
a local element/attribute has documentation, it will be displayed in a
window that pops up when the question mark inside the attribute or next
to the element is clicked, e.g. <postcode>. 
         
       
      
        
          Schema Component Representation 
        
        
          <complexType name ="AusAddress "> 
          <complexContent > 
          <extension base ="Address  
          <sequence > 
          <element name ="state " type ="AusStates  
          <element name ="postcode "> 
          <simpleType > 
          <restriction base ="string  
          <pattern value ="[1-9][0-9]{3} "/> 
          </restriction > 
          </simpleType > 
          </element > 
          </sequence > 
          <attribute name ="country " type ="string fixed ="Australia "/> 
          </extension > 
          </complexContent > 
          </complexType > 
          
       
      The
Schema Component Representation table above displays the underlying XML
representation of the schema component. (Annotations are not shown.)
      
       
    
      
      Abstract  
      All Model Group  in any order  in instances. See: http://www.w3.org/TR/xmlschema-1/#element-all .
      Choice Model Group  Only one  from the list of child elements and model groups can be provided in instances. See: http://www.w3.org/TR/xmlschema-1/#element-choice .
      Collapse Whitespace Policy  
      Disallowed Substitutions  substitution  is specified, then substitution group  members cannot be used in place of the given element declaration to validate element instances. If derivation methods ,
e.g. extension, restriction, are specified, then the given element
declaration will not validate element instances that have types derived
from the element declaration's type using the specified derivation
methods. Normally, element instances can override their declaration's
type by specifying an xsi:type attribute.
      Key Constraint  Uniqueness Constraint , but additionally requires that the specified value(s) must be provided. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions .
      Key Reference Constraint  Key Constraint  or Uniqueness Constraint . See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions .
      Model Group  http://www.w3.org/TR/xmlschema-1/#Model_Groups .
      Nillable  xsi:nil attribute. The xsi:nil attribute is the boolean attribute, nil , from the http://www.w3.org/2001/XMLSchema-instance  namespace. If an element instance has an xsi:nil attribute set to true, it can be left empty, even though its element declaration may have required content.
      Notation  http://www.w3.org/TR/xmlschema-1/#cNotation_Declarations .
      Preserve Whitespace Policy  
      Prohibited Derivations  
      Prohibited Substitutions  
      Replace Whitespace Policy  
      Sequence Model Group  in the specified order  in instances. See: http://www.w3.org/TR/xmlschema-1/#element-sequence .
      Substitution Group  members  of a substitution group can be used wherever the head  element of the substitution group is referenced.
      Substitution Group Exclusions  
      Target Namespace  
      Uniqueness Constraint  http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions .