summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc
blob: cf0bb9c5774929987a582edd3f7fb89ebd6c39d2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
#   From: http://www.w3.org/TR/rdf-sparql-query/#grammar 
# The entities implement productions [95] (PN_CHARS_BASE), [96] (PN_CHARS_U), [98] (PN_CHARS), [99] (PN_PREFIX),
# [100] (PN_LOCAL), [71] (PNAME_NS), [72] (PNAME_LN) and  [68] (PrefixedName)
# 
# PN_PREFIX is roughly equivalent to NCName.

default namespace = "http://www.w3.org/2002/07/owl#"

# The ontology
Prefix.type =
  attribute name {
    xsd:string {
      pattern =
        "([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]  ))?|"
    }
  },
  attribute IRI { xsd:anyURI }
start |= Prefix
Prefix = element Prefix { Prefix.type }
Import.type = attribute specialAttrs { text }
start |= Import
Import = element Import { Import.type }
Ontology.type =
  Prefix*,
  Import*,
  ontologyAnnotations,
  Axiom*,
  attribute ontologyIRI { xsd:anyURI }?,
  attribute versionIRI { xsd:anyURI }?,
  attribute specialAttrs { text }
start |= Ontology
Ontology = element Ontology { Ontology.type }
# Entities, anonymous individuals, and literals

# Note that the "Entity" group does not have a corresponding abstract type.
# This is due to the fact that XML Schema does not support multiple inheritence.
# "owl:Class" is both an entity and a class expression. The authors of this schema
# determined it was more useful to be able to retrieve "owl:Class" in such queries
# as schema(*, owl:ClassExpression).
Entity =
  Class
  | Datatype
  | ObjectProperty
  | DataProperty
  | AnnotationProperty
  | NamedIndividual
# This is the type for the attribute. The complex type for the element is capitalized.
abbreviatedIRI =
  xsd:string {
    pattern =
      "(((([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]  ))?)?:)(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|[0-9])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]))?))|((([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-῿]|[‌-‍]|[⁰-↏]|[Ⰰ-⿯]|[、-퟿]|[豈-﷏]|[ﷰ-�]|[𐀀-󯿿]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]  ))?)?:)"
  }
Class.type =
  ClassExpression,
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?
start |= Class
Class = element Class { Class.type }
Datatype.type =
  DataRange,
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?
start |= Datatype
Datatype = element Datatype { Datatype.type }
ObjectProperty.type =
  ObjectPropertyExpression,
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?
start |= ObjectProperty
ObjectProperty = element ObjectProperty { ObjectProperty.type }
DataProperty.type =
  DataPropertyExpression,
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?
start |= DataProperty
DataProperty = element DataProperty { DataProperty.type }
AnnotationProperty.type =
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?,
  attribute specialAttrs { text }
start |= AnnotationProperty
AnnotationProperty = element AnnotationProperty { AnnotationProperty.type }
Individual = attribute specialAttrs { text }, (NamedIndividual | AnonymousIndividual)
NamedIndividual.type =
  Individual,
  attribute IRI { xsd:anyURI }?,
  attribute abbreviatedIRI { abbreviatedIRI }?
start |= NamedIndividual
NamedIndividual = element NamedIndividual { NamedIndividual.type }
AnonymousIndividual.type =
  Individual,
  attribute nodeID { xsd:NCName }
start |= AnonymousIndividual
AnonymousIndividual =
  element AnonymousIndividual { AnonymousIndividual.type }
Literal.type =
  attribute datatypeIRI { xsd:anyURI },
  attribute specialAttrs { text }
start |= Literal
Literal = element Literal { Literal.type }
# Declarations
Declaration.type = Axiom, Entity
start |= Declaration
Declaration = element Declaration { Declaration.type }
# Object property expressions
ObjectPropertyExpression = attribute specialAttrs { text }, (ObjectProperty | ObjectInverseOf)
ObjectInverseOf.type = ObjectPropertyExpression, ObjectProperty
start |= ObjectInverseOf
ObjectInverseOf = element ObjectInverseOf { ObjectInverseOf.type }
# Data property expressions
DataPropertyExpression = attribute specialAttrs { text }, DataProperty
# Data ranges
DataRange = attribute specialAttrs { text },
 (Datatype
  | DataIntersectionOf
  | DataUnionOf
  | DataComplementOf
  | DataOneOf
  | DatatypeRestriction)
DataIntersectionOf.type = DataRange, DataRange+
start |= DataIntersectionOf
DataIntersectionOf = element DataIntersectionOf { DataIntersectionOf.type }
DataUnionOf.type = DataRange, DataRange+
start |= DataUnionOf
DataUnionOf = element DataUnionOf { DataUnionOf.type }
DataComplementOf.type = DataRange, DataRange
start |= DataComplementOf
DataComplementOf = element DataComplementOf { DataComplementOf.type }
DataOneOf.type = DataRange, Literal+
start |= DataOneOf
DataOneOf = element DataOneOf { DataOneOf.type }
DatatypeRestriction.type =
  DataRange,
  Datatype,
  element FacetRestriction { FacetRestriction }+
start |= DatatypeRestriction
DatatypeRestriction =
  element DatatypeRestriction { DatatypeRestriction.type }
FacetRestriction =
  Literal,
  attribute facet { xsd:anyURI },
  attribute specialAttrs { text }
# Class expressions
ClassExpression = attribute specialAttrs { text },
 (Class
  | ObjectIntersectionOf
  | ObjectUnionOf
  | ObjectComplementOf
  | ObjectOneOf
  | ObjectSomeValuesFrom
  | ObjectAllValuesFrom
  | ObjectHasValue
  | ObjectHasSelf
  | ObjectMinCardinality
  | ObjectMaxCardinality
  | ObjectExactCardinality
  | DataSomeValuesFrom
  | DataAllValuesFrom
  | DataHasValue
  | DataMinCardinality
  | DataMaxCardinality
  | DataExactCardinality)
ObjectIntersectionOf.type = ClassExpression, ClassExpression+
start |= ObjectIntersectionOf
ObjectIntersectionOf =
  element ObjectIntersectionOf { ObjectIntersectionOf.type }
ObjectUnionOf.type = ClassExpression, ClassExpression+
start |= ObjectUnionOf
ObjectUnionOf = element ObjectUnionOf { ObjectUnionOf.type }
ObjectComplementOf.type = ClassExpression, ClassExpression
start |= ObjectComplementOf
ObjectComplementOf = element ObjectComplementOf { ObjectComplementOf.type }
ObjectOneOf.type = ClassExpression, Individual+
start |= ObjectOneOf
ObjectOneOf = element ObjectOneOf { ObjectOneOf.type }
ObjectSomeValuesFrom.type =
  ClassExpression, ObjectPropertyExpression, ClassExpression
start |= ObjectSomeValuesFrom
ObjectSomeValuesFrom =
  element ObjectSomeValuesFrom { ObjectSomeValuesFrom.type }
ObjectAllValuesFrom.type =
  ClassExpression, ObjectPropertyExpression, ClassExpression
start |= ObjectAllValuesFrom
ObjectAllValuesFrom =
  element ObjectAllValuesFrom { ObjectAllValuesFrom.type }
ObjectHasValue.type = ClassExpression, ObjectPropertyExpression, Individual
start |= ObjectHasValue
ObjectHasValue = element ObjectHasValue { ObjectHasValue.type }
ObjectHasSelf.type = ClassExpression, ObjectPropertyExpression
start |= ObjectHasSelf
ObjectHasSelf = element ObjectHasSelf { ObjectHasSelf.type }
ObjectMinCardinality.type =
  ClassExpression,
  ObjectPropertyExpression,
  ClassExpression?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= ObjectMinCardinality
ObjectMinCardinality =
  element ObjectMinCardinality { ObjectMinCardinality.type }
ObjectMaxCardinality.type =
  ClassExpression,
  ObjectPropertyExpression,
  ClassExpression?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= ObjectMaxCardinality
ObjectMaxCardinality =
  element ObjectMaxCardinality { ObjectMaxCardinality.type }
ObjectExactCardinality.type =
  ClassExpression,
  ObjectPropertyExpression,
  ClassExpression?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= ObjectExactCardinality
ObjectExactCardinality =
  element ObjectExactCardinality { ObjectExactCardinality.type }
DataSomeValuesFrom.type = ClassExpression, DataPropertyExpression+, DataRange
start |= DataSomeValuesFrom
DataSomeValuesFrom = element DataSomeValuesFrom { DataSomeValuesFrom.type }
DataAllValuesFrom.type = ClassExpression, DataPropertyExpression+, DataRange
start |= DataAllValuesFrom
DataAllValuesFrom = element DataAllValuesFrom { DataAllValuesFrom.type }
DataHasValue.type = ClassExpression, DataPropertyExpression, Literal
start |= DataHasValue
DataHasValue = element DataHasValue { DataHasValue.type }
DataMinCardinality.type =
  ClassExpression,
  DataPropertyExpression,
  DataRange?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= DataMinCardinality
DataMinCardinality = element DataMinCardinality { DataMinCardinality.type }
DataMaxCardinality.type =
  ClassExpression,
  DataPropertyExpression,
  DataRange?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= DataMaxCardinality
DataMaxCardinality = element DataMaxCardinality { DataMaxCardinality.type }
DataExactCardinality.type =
  ClassExpression,
  DataPropertyExpression,
  DataRange?,
  attribute cardinality { xsd:nonNegativeInteger }
start |= DataExactCardinality
DataExactCardinality =
  element DataExactCardinality { DataExactCardinality.type }
# Axioms
Axiom = axiomAnnotations, attribute specialAttrs { text },
 (Declaration
  | ClassAxiom
  | ObjectPropertyAxiom
  | DataPropertyAxiom
  | DatatypeDefinition
  | HasKey
  | Assertion
  | AnnotationAxiom)
# Class expression axioms
ClassAxiom = Axiom | SubClassOf | EquivalentClasses | DisjointClasses | DisjointUnion
SubClassOf.type =
  ClassAxiom,
  ClassExpression,
  # This is the subexpression
  ClassExpression
  # This is the superexpression
  
start |= SubClassOf
SubClassOf = element SubClassOf { SubClassOf.type }
EquivalentClasses.type = ClassAxiom, ClassExpression+
start |= EquivalentClasses
EquivalentClasses = element EquivalentClasses { EquivalentClasses.type }
DisjointClasses.type = ClassAxiom, ClassExpression+
start |= DisjointClasses
DisjointClasses = element DisjointClasses { DisjointClasses.type }
DisjointUnion.type = ClassAxiom, Class, ClassExpression+
start |= DisjointUnion
DisjointUnion = element DisjointUnion { DisjointUnion.type }
# Object property axioms
ObjectPropertyAxiom = Axiom| 
  SubObjectPropertyOf
  | EquivalentObjectProperties
  | DisjointObjectProperties
  | InverseObjectProperties
  | ObjectPropertyDomain
  | ObjectPropertyRange
  | FunctionalObjectProperty
  | InverseFunctionalObjectProperty
  | ReflexiveObjectProperty
  | IrreflexiveObjectProperty
  | SymmetricObjectProperty
  | AsymmetricObjectProperty
  | TransitiveObjectProperty
SubObjectPropertyOf.type =
  ObjectPropertyAxiom,
  (# This is the subproperty expression or the property chain
   ObjectPropertyExpression
   | element ObjectPropertyChain { ObjectPropertyChain.type }),
  ObjectPropertyExpression
  # This is the superproperty expression
  
start |= SubObjectPropertyOf
SubObjectPropertyOf =
  element SubObjectPropertyOf { SubObjectPropertyOf.type }
ObjectPropertyChain.type =
  ObjectPropertyExpression+,
  attribute specialAttrs { text }
EquivalentObjectProperties.type =
  ObjectPropertyAxiom, ObjectPropertyExpression+
start |= EquivalentObjectProperties
EquivalentObjectProperties =
  element EquivalentObjectProperties { EquivalentObjectProperties.type }
DisjointObjectProperties.type =
  ObjectPropertyAxiom, ObjectPropertyExpression+
start |= DisjointObjectProperties
DisjointObjectProperties =
  element DisjointObjectProperties { DisjointObjectProperties.type }
ObjectPropertyDomain.type =
  ObjectPropertyAxiom, ObjectPropertyExpression, ClassExpression
start |= ObjectPropertyDomain
ObjectPropertyDomain =
  element ObjectPropertyDomain { ObjectPropertyDomain.type }
ObjectPropertyRange.type =
  ObjectPropertyAxiom, ObjectPropertyExpression, ClassExpression
start |= ObjectPropertyRange
ObjectPropertyRange =
  element ObjectPropertyRange { ObjectPropertyRange.type }
InverseObjectProperties.type =
  ObjectPropertyAxiom,
  ObjectPropertyExpression,
  ObjectPropertyExpression
start |= InverseObjectProperties
InverseObjectProperties =
  element InverseObjectProperties { InverseObjectProperties.type }
FunctionalObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression
start |= FunctionalObjectProperty
FunctionalObjectProperty =
  element FunctionalObjectProperty { FunctionalObjectProperty.type }
InverseFunctionalObjectProperty.type =
  ObjectPropertyAxiom, ObjectPropertyExpression
start |= InverseFunctionalObjectProperty
InverseFunctionalObjectProperty =
  element InverseFunctionalObjectProperty {
    InverseFunctionalObjectProperty.type
  }
ReflexiveObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression
start |= ReflexiveObjectProperty
ReflexiveObjectProperty =
  element ReflexiveObjectProperty { ReflexiveObjectProperty.type }
IrreflexiveObjectProperty.type =
  ObjectPropertyAxiom, ObjectPropertyExpression
start |= IrreflexiveObjectProperty
IrreflexiveObjectProperty =
  element IrreflexiveObjectProperty { IrreflexiveObjectProperty.type }
SymmetricObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression
start |= SymmetricObjectProperty
SymmetricObjectProperty =
  element SymmetricObjectProperty { SymmetricObjectProperty.type }
AsymmetricObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression
start |= AsymmetricObjectProperty
AsymmetricObjectProperty =
  element AsymmetricObjectProperty { AsymmetricObjectProperty.type }
TransitiveObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression
start |= TransitiveObjectProperty
TransitiveObjectProperty =
  element TransitiveObjectProperty { TransitiveObjectProperty.type }
# Data property axioms
DataPropertyAxiom = Axiom | 
 SubDataPropertyOf
  | EquivalentDataProperties
  | DisjointDataProperties
  | DataPropertyDomain
  | DataPropertyRange
  | FunctionalDataProperty
SubDataPropertyOf.type =
  DataPropertyAxiom,
  DataPropertyExpression,
  # This is the subproperty expression
  DataPropertyExpression
  # This is the superproperty expression
  
start |= SubDataPropertyOf
SubDataPropertyOf = element SubDataPropertyOf { SubDataPropertyOf.type }
EquivalentDataProperties.type = DataPropertyAxiom, DataPropertyExpression+
start |= EquivalentDataProperties
EquivalentDataProperties =
  element EquivalentDataProperties { EquivalentDataProperties.type }
DisjointDataProperties.type = DataPropertyAxiom, DataPropertyExpression+
start |= DisjointDataProperties
DisjointDataProperties =
  element DisjointDataProperties { DisjointDataProperties.type }
DataPropertyDomain.type =
  DataPropertyAxiom, DataPropertyExpression, ClassExpression
start |= DataPropertyDomain
DataPropertyDomain = element DataPropertyDomain { DataPropertyDomain.type}
DataPropertyRange.type = DataPropertyAxiom, DataPropertyExpression, DataRange
start |= DataPropertyRange
DataPropertyRange = element DataPropertyRange { DataPropertyRange.type }
FunctionalDataProperty.type = DataPropertyAxiom, DataPropertyExpression
start |= FunctionalDataProperty
FunctionalDataProperty =
  element FunctionalDataProperty { FunctionalDataProperty.type }
# Datatype definitions
DatatypeDefinition.type = Axiom, Datatype, DataRange
start |= DatatypeDefinition
DatatypeDefinition = element DatatypeDefinition { DatatypeDefinition.type }
# Key axioms
HasKey.type =
  Axiom,
  ClassExpression,
  ObjectPropertyExpression*,
  DataPropertyExpression*
start |= HasKey
HasKey = element HasKey { HasKey.type }
# Assertions
Assertion = Axiom  | 
  SameIndividual
  | DifferentIndividuals
  | ClassAssertion
  | ObjectPropertyAssertion
  | NegativeObjectPropertyAssertion
  | DataPropertyAssertion
  | NegativeDataPropertyAssertion
SameIndividual.type = Assertion, Individual+
start |= SameIndividual
SameIndividual = element SameIndividual { SameIndividual.type }
DifferentIndividuals.type = Assertion, Individual+
start |= DifferentIndividuals
DifferentIndividuals =
  element DifferentIndividuals { DifferentIndividuals.type }
ClassAssertion.type = Assertion, ClassExpression, Individual
start |= ClassAssertion
ClassAssertion = element ClassAssertion { ClassAssertion.type }
ObjectPropertyAssertion.type =
  Assertion,
  ObjectPropertyExpression,
  Individual,
  # This is the source invididual
  Individual
  # This is the target individual
  
start |= ObjectPropertyAssertion
ObjectPropertyAssertion =
  element ObjectPropertyAssertion { ObjectPropertyAssertion.type }
NegativeObjectPropertyAssertion.type =
  Assertion,
  ObjectPropertyExpression,
  Individual,
  # This is the source invididual
  Individual
  # This is the target individual
  
start |= NegativeObjectPropertyAssertion
NegativeObjectPropertyAssertion =
  element NegativeObjectPropertyAssertion {
    NegativeObjectPropertyAssertion.type
  }
DataPropertyAssertion.type =
  Assertion,
  DataPropertyExpression,
  Individual,
  # This is the source invididual
  Literal
  # This is the target individual
  
start |= DataPropertyAssertion
DataPropertyAssertion =
  element DataPropertyAssertion { DataPropertyAssertion.type }
NegativeDataPropertyAssertion.type =
  Assertion,
  DataPropertyExpression,
  Individual,
  # This is the source invididual
  Literal
  # This is the target individual
  
start |= NegativeDataPropertyAssertion
NegativeDataPropertyAssertion =
  element NegativeDataPropertyAssertion {
    NegativeDataPropertyAssertion.type
  }
# Annotations
IRI.type = attribute specialAttrs { text }
start |= IRI
IRI = element IRI { IRI.type }
AbbreviatedIRI.type = attribute specialAttrs { text }
start |= AbbreviatedIRI
AbbreviatedIRI = element AbbreviatedIRI { AbbreviatedIRI.type }
AnnotationSubject = IRI | AbbreviatedIRI | AnonymousIndividual
AnnotationValue = IRI | AbbreviatedIRI | AnonymousIndividual | Literal
Annotation.type =
  annotationAnnotations,
  AnnotationProperty,
  AnnotationValue,
  attribute specialAttrs { text }
start |= Annotation
Annotation = element Annotation { Annotation.type }
axiomAnnotations = Annotation*
ontologyAnnotations = Annotation*
annotationAnnotations = Annotation*
# Annotation axioms
AnnotationAxiom = Axiom | 
 AnnotationAssertion
  | SubAnnotationPropertyOf
  | AnnotationPropertyDomain
  | AnnotationPropertyRange
AnnotationAssertion.type =
  AnnotationAxiom,
  AnnotationProperty,
  AnnotationSubject,
  AnnotationValue
start |= AnnotationAssertion
AnnotationAssertion =
  element AnnotationAssertion { AnnotationAssertion.type }
SubAnnotationPropertyOf.type =
  AnnotationAxiom,
  AnnotationProperty,
  # This is the subproperty
  AnnotationProperty
  # This is the superproperty
  
start |= SubAnnotationPropertyOf
SubAnnotationPropertyOf =
  element SubAnnotationPropertyOf { SubAnnotationPropertyOf.type }
AnnotationPropertyDomain.type =
  AnnotationAxiom, AnnotationProperty, IRI, AbbreviatedIRI
start |= AnnotationPropertyDomain
AnnotationPropertyDomain =
  element AnnotationPropertyDomain { AnnotationPropertyDomain.type }
AnnotationPropertyRange.type =
  AnnotationAxiom, AnnotationProperty, IRI, AbbreviatedIRI
start |= AnnotationPropertyRange
AnnotationPropertyRange =
  element AnnotationPropertyRange { AnnotationPropertyRange.type }