# 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 }