https://github.com/UFOKN/Knowledge-Graph
Tip revision: 4b80c683fa9b83d85e3cb09cadc608069172e308 authored by David Kedrowski on 19 April 2024, 19:34:46 UTC
updated for hasCriticalFloodObservation relation
updated for hasCriticalFloodObservation relation
Tip revision: 4b80c68
ufokn_owl2-rl.pie
/* OWLIM rules and axioms for the TRREE engine
*
* This file holds the entailment rules and consistency checks for the OWL2 RL profile,
* see http://www.w3.org/TR/owl2-profiles/#OWL_2_RL
*
* Every rule consists of one or more premises and one or more corollaries
* in the following format:
*
* Rules
* {
* Id: Rule_Id
* < Premise #1 >
* < Premise #2 >
* . . .
* < Premise #n >
* ---------------------
* < Corollary #1 >
* < Corollary #2 >
* . . .
* < Corollary #m >
* }
*
* Every premise may contain constraints stating that the value of one or
* more variables in the statement must not be equal to a full URI, a short name
* or the value of another variable from the same rule.
* This is written in the following format:
*
* . . . . . . . . . . .
* a <mynamespace:myproperty> b [Constraint a != b]
* <mynamespace:Instance_1.0> a c [Constraint a != <rdf:type>, c != a, c != b]
* -----------------------------------
* c a b
* b <rdf:type> <mynamespace:Instance_1.0> [Constraint b != <http://www.w3.org/2000/01/rdf-schema#Class>]
*
* Every left value in the not-equal constraint must denote a variable
* and every right value can be a variable, a short name or a full URI.
* Not-equal constraints may be used to force the engine not to apply
* the rule when the constraints are not satisfied. This will improve
* engine's performance.
* Constraints are valid anywhere within the rule-body.
* If a variable is not bound yet then the constraint is considered satisfied
* (and therefore does not apply).
* In the rule head, a constraint only affects the production of the rule conclusion it neighbours.
*
* In addition one or more axioms may be added in the following format:
*
* Axioms
* {
* < Axiom #1 >
* < Axiom #2 >
* . . .
* < Axiom #n >
* }
*
* The premises, the corollaries and the axioms must be written in N-Triple format.
* The subject, the predicate and the object must denote a full URI or
* a short name in format <Prefix>:<LocalName> where <Prefix> is defined in
* the prefix section written in the following format:
*
* Prefices
* {
* < Prefix #1 > : < Full URI for prefix #1 >
* < Prefix #2 > : < Full URI for prefix #2 >
* . . . . . . . . . . . . . .
* < Prefix #n > : < Full URI for prefix #n >
* }
*
* The sections must be arranged in the following order:
*
* Prefices // If any
* {
* . . .
* }
* Axioms // If any
* {
* . . .
* }
* Rules // Must necessarily be present
* {
* . . .
* }
*
* Variables in rules are alpha-numeric and must NOT be surrounded by angle braces.
*/
Prefices
{
rdf : http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfs : http://www.w3.org/2000/01/rdf-schema#
owl : http://www.w3.org/2002/07/owl#
xsd : http://www.w3.org/2001/XMLSchema#
onto : http://www.ontotext.com/
ufokn_c : http://schema.ufokn.org/utility-connection/v2/
}
Axioms
{
// ========================================================================
// RDF axiomatic triples
// ========================================================================
// The following RDF axiomatic triples were taken from here:
// http://www.w3.org/TR/rdf-mt/#RDFINTERP
// ========================================================================
<rdf:type> <rdf:type> <rdf:Property>
<rdf:subject> <rdf:type> <rdf:Property>
<rdf:predicate> <rdf:type> <rdf:Property>
<rdf:object> <rdf:type> <rdf:Property>
<rdf:first> <rdf:type> <rdf:Property>
<rdf:rest> <rdf:type> <rdf:Property>
<rdf:value> <rdf:type> <rdf:Property>
<rdf:_1> <rdf:type> <rdf:Property>
<rdf:nil> <rdf:type> <rdf:List>
// ========================================================================
// RDFS axiomatic triples
// ========================================================================
// The following RDFS axiomatic triples were taken from here:
// http://www.w3.org/TR/rdf-mt/#RDFSINTERP
// ========================================================================
<rdf:type> <rdfs:domain> <rdfs:Resource>
<rdfs:domain> <rdfs:domain> <rdf:Property>
<rdfs:range> <rdfs:domain> <rdf:Property>
<rdfs:subPropertyOf> <rdfs:domain> <rdf:Property>
<rdfs:subClassOf> <rdfs:domain> <rdfs:Class>
<rdf:Statement> <rdf:type> <rdfs:Class>
<rdf:subject> <rdfs:domain> <rdf:Statement>
<rdf:predicate> <rdfs:domain> <rdf:Statement>
<rdf:object> <rdfs:domain> <rdf:Statement>
<rdfs:member> <rdfs:domain> <rdfs:Resource>
<rdf:first> <rdfs:domain> <rdf:List>
<rdf:rest> <rdfs:domain> <rdf:List>
<rdfs:seeAlso> <rdfs:domain> <rdfs:Resource>
<rdfs:isDefinedBy> <rdfs:domain> <rdfs:Resource>
<rdfs:comment> <rdfs:domain> <rdfs:Resource>
<rdfs:label> <rdfs:domain> <rdfs:Resource>
<rdf:value> <rdfs:domain> <rdfs:Resource>
// <rdf:type> <rdfs:range> <rdfs:Class>
<rdfs:domain> <rdfs:range> <rdfs:Class>
<rdfs:range> <rdfs:range> <rdfs:Class>
<rdfs:subPropertyOf> <rdfs:range> <rdf:Property>
<rdfs:subClassOf> <rdfs:range> <rdfs:Class>
<rdf:subject> <rdfs:range> <rdfs:Resource>
<rdf:predicate> <rdfs:range> <rdfs:Resource>
<rdf:object> <rdfs:range> <rdfs:Resource>
<rdfs:member> <rdfs:range> <rdfs:Resource>
<rdf:first> <rdfs:range> <rdfs:Resource>
<rdf:rest> <rdfs:range> <rdf:List>
<rdfs:seeAlso> <rdfs:range> <rdfs:Resource>
<rdfs:isDefinedBy> <rdfs:range> <rdfs:Resource>
<rdfs:comment> <rdfs:range> <rdfs:Literal>
<rdfs:label> <rdfs:range> <rdfs:Literal>
<rdf:value> <rdfs:range> <rdfs:Resource>
<rdf:Alt> <rdfs:subClassOf> <rdfs:Container>
<rdf:Bag> <rdfs:subClassOf> <rdfs:Container>
<rdf:Seq> <rdfs:subClassOf> <rdfs:Container>
<rdfs:ContainerMembershipProperty> <rdfs:subClassOf> <rdf:Property>
<rdfs:isDefinedBy> <rdfs:subPropertyOf> <rdfs:seeAlso>
<rdf:XMLLiteral> <rdf:type> <rdfs:Datatype>
<rdf:XMLLiteral> <rdfs:subClassOf> <rdfs:Literal>
<rdfs:Datatype> <rdfs:subClassOf> <rdfs:Class>
<rdf:_1> <rdf:type> <rdfs:ContainerMembershipProperty>
<rdf:_1> <rdfs:domain> <rdfs:Resource>
<rdf:_1> <rdfs:range> <rdfs:Resource>
// ========================================================================
// OWL Vocabulary
// ========================================================================
// The following 'axiomatic triples for the OWL vocabulary were taken from here:
// http://www.w3.org/TR/2009/REC-owl2-rdf-based-semantics-20091027/#A_Set_of_Axiomatic_Triples
// ========================================================================
// Table 6.1: Axiomatic Triples for the Classes of the OWL 2 RDF-Based Vocabulary
<owl:AllDifferent> <rdf:type> <rdfs:Class>
<owl:AllDifferent> <rdfs:subClassOf> <rdfs:Resource>
<owl:AllDisjointClasses> <rdf:type> <rdfs:Class>
<owl:AllDisjointClasses> <rdfs:subClassOf> <rdfs:Resource>
<owl:AllDisjointProperties> <rdf:type> <rdfs:Class>
<owl:AllDisjointProperties> <rdfs:subClassOf> <rdfs:Resource>
<owl:Annotation> <rdf:type> <rdfs:Class>
<owl:Annotation> <rdfs:subClassOf> <rdfs:Resource>
<owl:AnnotationProperty> <rdf:type> <rdfs:Class>
<owl:AnnotationProperty> <rdfs:subClassOf> <rdf:Property>
<owl:AsymmetricProperty> <rdf:type> <rdfs:Class>
<owl:AsymmetricProperty> <rdfs:subClassOf> <owl:ObjectProperty>
<owl:Axiom> <rdf:type> <rdfs:Class>
<owl:Axiom> <rdfs:subClassOf> <rdfs:Resource>
<owl:Class> <rdf:type> <rdfs:Class>
<owl:Class> <rdfs:subClassOf> <rdfs:Class>
<owl:DataRange> <rdf:type> <rdfs:Class>
<owl:DataRange> <rdfs:subClassOf> <rdfs:Datatype>
<owl:DatatypeProperty> <rdf:type> <rdfs:Class>
<owl:DatatypeProperty> <rdfs:subClassOf> <rdf:Property>
<owl:DeprecatedClass> <rdf:type> <rdfs:Class>
<owl:DeprecatedClass> <rdfs:subClassOf> <rdfs:Class>
<owl:DeprecatedProperty> <rdf:type> <rdfs:Class>
<owl:DeprecatedProperty> <rdfs:subClassOf> <rdf:Property>
<owl:FunctionalProperty> <rdf:type> <rdfs:Class>
<owl:FunctionalProperty> <rdfs:subClassOf> <rdf:Property>
<owl:InverseFunctionalProperty> <rdf:type> <rdfs:Class>
<owl:InverseFunctionalProperty> <rdfs:subClassOf> <owl:ObjectProperty>
<owl:IrreflexiveProperty> <rdf:type> <rdfs:Class>
<owl:IrreflexiveProperty> <rdfs:subClassOf> <owl:ObjectProperty>
<owl:NamedIndividual> <rdf:type> <rdfs:Class>
<owl:NamedIndividual> <rdfs:subClassOf> <owl:Thing>
<owl:NegativePropertyAssertion> <rdf:type> <rdfs:Class>
<owl:NegativePropertyAssertion> <rdfs:subClassOf> <rdfs:Resource>
<owl:Nothing> <rdf:type> <owl:Class>
<owl:Nothing> <rdfs:subClassOf> <owl:Thing>
<owl:ObjectProperty> <rdf:type> <rdfs:Class>
<owl:ObjectProperty> <rdfs:subClassOf> <rdf:Property>
<owl:Ontology> <rdf:type> <rdfs:Class>
<owl:Ontology> <rdfs:subClassOf> <rdfs:Resource>
<owl:OntologyProperty> <rdf:type> <rdfs:Class>
<owl:OntologyProperty> <rdfs:subClassOf> <rdf:Property>
<owl:ReflexiveProperty> <rdf:type> <rdfs:Class>
<owl:ReflexiveProperty> <rdfs:subClassOf> <owl:ObjectProperty>
<owl:Restriction> <rdf:type> <rdfs:Class>
<owl:Restriction> <rdfs:subClassOf> <owl:Class>
<owl:SymmetricProperty> <rdf:type> <rdfs:Class>
<owl:SymmetricProperty> <rdfs:subClassOf> <owl:ObjectProperty>
<owl:Thing> <rdf:type> <owl:Class>
<owl:TransitiveProperty> <rdf:type> <rdfs:Class>
<owl:TransitiveProperty> <rdfs:subClassOf> <owl:ObjectProperty>
// Table 6.2: Axiomatic Triples for the Properties of the OWL 2 RDF-Based Vocabulary
<owl:allValuesFrom> <rdf:type> <rdf:Property>
<owl:allValuesFrom> <rdfs:domain> <owl:Restriction>
<owl:allValuesFrom> <rdfs:range> <rdfs:Class>
<owl:annotatedProperty> <rdf:type> <rdf:Property>
<owl:annotatedProperty> <rdfs:domain> <rdfs:Resource>
<owl:annotatedProperty> <rdfs:range> <rdfs:Resource>
<owl:annotatedSource> <rdf:type> <rdf:Property>
<owl:annotatedSource> <rdfs:domain> <rdfs:Resource>
<owl:annotatedSource> <rdfs:range> <rdfs:Resource>
<owl:annotatedTarget> <rdf:type> <rdf:Property>
<owl:annotatedTarget> <rdfs:domain> <rdfs:Resource>
<owl:annotatedTarget> <rdfs:range> <rdfs:Resource>
<owl:assertionProperty> <rdf:type> <rdf:Property>
<owl:assertionProperty> <rdfs:domain> <owl:NegativePropertyAssertion>
<owl:assertionProperty> <rdfs:range> <rdf:Property>
<owl:backwardCompatibleWith> <rdf:type> <owl:AnnotationProperty>
<owl:backwardCompatibleWith> <rdf:type> <owl:OntologyProperty>
<owl:backwardCompatibleWith> <rdfs:domain> <owl:Ontology>
<owl:backwardCompatibleWith> <rdfs:range> <owl:Ontology>
<owl:bottomDataProperty> <rdf:type> <owl:DatatypeProperty>
<owl:bottomDataProperty> <rdfs:domain> <owl:Thing>
<owl:bottomDataProperty> <rdfs:range> <rdfs:Literal>
<owl:bottomObjectProperty> <rdf:type> <owl:ObjectProperty>
<owl:bottomObjectProperty> <rdfs:domain> <owl:Thing>
<owl:bottomObjectProperty> <rdfs:range> <owl:Thing>
<owl:cardinality> <rdf:type> <rdf:Property>
<owl:cardinality> <rdfs:domain> <owl:Restriction>
<owl:cardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:complementOf> <rdf:type> <rdf:Property>
<owl:complementOf> <rdfs:domain> <owl:Class>
<owl:complementOf> <rdfs:range> <owl:Class>
<owl:datatypeComplementOf> <rdf:type> <rdf:Property>
<owl:datatypeComplementOf> <rdfs:domain> <rdfs:Datatype>
<owl:datatypeComplementOf> <rdfs:range> <rdfs:Datatype>
<owl:deprecated> <rdf:type> <owl:AnnotationProperty>
<owl:deprecated> <rdfs:domain> <rdfs:Resource>
<owl:deprecated> <rdfs:range> <rdfs:Resource>
<owl:differentFrom> <rdf:type> <rdf:Property>
<owl:differentFrom> <rdfs:domain> <owl:Thing>
<owl:differentFrom> <rdfs:range> <owl:Thing>
<owl:disjointUnionOf> <rdf:type> <rdf:Property>
<owl:disjointUnionOf> <rdfs:domain> <owl:Class>
<owl:disjointUnionOf> <rdfs:range> <rdf:List>
<owl:disjointWith> <rdf:type> <rdf:Property>
<owl:disjointWith> <rdfs:domain> <owl:Class>
<owl:disjointWith> <rdfs:range> <owl:Class>
<owl:distinctMembers> <rdf:type> <rdf:Property>
<owl:distinctMembers> <rdfs:domain> <owl:AllDifferent>
<owl:distinctMembers> <rdfs:range> <rdf:List>
<owl:equivalentClass> <rdf:type> <rdf:Property>
<owl:equivalentClass> <rdfs:domain> <rdfs:Class>
<owl:equivalentClass> <rdfs:range> <rdfs:Class>
<owl:equivalentProperty> <rdf:type> <rdf:Property>
<owl:equivalentProperty> <rdfs:domain> <rdf:Property>
<owl:equivalentProperty> <rdfs:range> <rdf:Property>
<owl:hasKey> <rdf:type> <rdf:Property>
<owl:hasKey> <rdfs:domain> <owl:Class>
<owl:hasKey> <rdfs:range> <rdf:List>
<owl:hasSelf> <rdf:type> <rdf:Property>
<owl:hasSelf> <rdfs:domain> <owl:Restriction>
<owl:hasSelf> <rdfs:range> <rdfs:Resource>
<owl:hasValue> <rdf:type> <rdf:Property>
<owl:hasValue> <rdfs:domain> <owl:Restriction>
<owl:hasValue> <rdfs:range> <rdfs:Resource>
<owl:imports> <rdf:type> <owl:OntologyProperty>
<owl:imports> <rdfs:domain> <owl:Ontology>
<owl:imports> <rdfs:range> <owl:Ontology>
<owl:incompatibleWith> <rdf:type> <owl:AnnotationProperty>
<owl:incompatibleWith> <rdf:type> <owl:OntologyProperty>
<owl:incompatibleWith> <rdfs:domain> <owl:Ontology>
<owl:incompatibleWith> <rdfs:range> <owl:Ontology>
<owl:intersectionOf> <rdf:type> <rdf:Property>
<owl:intersectionOf> <rdfs:domain> <rdfs:Class>
<owl:intersectionOf> <rdfs:range> <rdf:List>
<owl:inverseOf> <rdf:type> <rdf:Property>
<owl:inverseOf> <rdfs:domain> <owl:ObjectProperty>
<owl:inverseOf> <rdfs:range> <owl:ObjectProperty>
<owl:maxCardinality> <rdf:type> <rdf:Property>
<owl:maxCardinality> <rdfs:domain> <owl:Restriction>
<owl:maxCardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:maxQualifiedCardinality> <rdf:type> <rdf:Property>
<owl:maxQualifiedCardinality> <rdfs:domain> <owl:Restriction>
<owl:maxQualifiedCardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:members> <rdf:type> <rdf:Property>
<owl:members> <rdfs:domain> <rdfs:Resource>
<owl:members> <rdfs:range> <rdf:List>
<owl:minCardinality> <rdf:type> <rdf:Property>
<owl:minCardinality> <rdfs:domain> <owl:Restriction>
<owl:minCardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:minQualifiedCardinality> <rdf:type> <rdf:Property>
<owl:minQualifiedCardinality> <rdfs:domain> <owl:Restriction>
<owl:minQualifiedCardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:onClass> <rdf:type> <rdf:Property>
<owl:onClass> <rdfs:domain> <owl:Restriction>
<owl:onClass> <rdfs:range> <owl:Class>
<owl:onDataRange> <rdf:type> <rdf:Property>
<owl:onDataRange> <rdfs:domain> <owl:Restriction>
<owl:onDataRange> <rdfs:range> <rdfs:Datatype>
<owl:onDatatype> <rdf:type> <rdf:Property>
<owl:onDatatype> <rdfs:domain> <rdfs:Datatype>
<owl:onDatatype> <rdfs:range> <rdfs:Datatype>
<owl:oneOf> <rdf:type> <rdf:Property>
<owl:oneOf> <rdfs:domain> <rdfs:Class>
<owl:oneOf> <rdfs:range> <rdf:List>
<owl:onProperty> <rdf:type> <rdf:Property>
<owl:onProperty> <rdfs:domain> <owl:Restriction>
<owl:onProperty> <rdfs:range> <rdf:Property>
<owl:onProperties> <rdf:type> <rdf:Property>
<owl:onProperties> <rdfs:domain> <owl:Restriction>
<owl:onProperties> <rdfs:range> <rdf:List>
<owl:priorVersion> <rdf:type> <owl:AnnotationProperty>
<owl:priorVersion> <rdf:type> <owl:OntologyProperty>
<owl:priorVersion> <rdfs:domain> <owl:Ontology>
<owl:priorVersion> <rdfs:range> <owl:Ontology>
<owl:propertyChainAxiom> <rdf:type> <rdf:Property>
<owl:propertyChainAxiom> <rdfs:domain> <owl:ObjectProperty>
<owl:propertyChainAxiom> <rdfs:range> <rdf:List>
<owl:propertyDisjointWith> <rdf:type> <rdf:Property>
<owl:propertyDisjointWith> <rdfs:domain> <rdf:Property>
<owl:propertyDisjointWith> <rdfs:range> <rdf:Property>
<owl:qualifiedCardinality> <rdf:type> <rdf:Property>
<owl:qualifiedCardinality> <rdfs:domain> <owl:Restriction>
<owl:qualifiedCardinality> <rdfs:range> <xsd:nonNegativeInteger>
<owl:sameAs> <rdf:type> <rdf:Property>
<owl:sameAs> <rdfs:domain> <owl:Thing>
<owl:sameAs> <rdfs:range> <owl:Thing>
<owl:someValuesFrom> <rdf:type> <rdf:Property>
<owl:someValuesFrom> <rdfs:domain> <owl:Restriction>
<owl:someValuesFrom> <rdfs:range> <rdfs:Class>
<owl:sourceIndividual> <rdf:type> <rdf:Property>
<owl:sourceIndividual> <rdfs:domain> <owl:NegativePropertyAssertion>
<owl:sourceIndividual> <rdfs:range> <owl:Thing>
<owl:targetIndividual> <rdf:type> <rdf:Property>
<owl:targetIndividual> <rdfs:domain> <owl:NegativePropertyAssertion>
<owl:targetIndividual> <rdfs:range> <owl:Thing>
<owl:targetValue> <rdf:type> <rdf:Property>
<owl:targetValue> <rdfs:domain> <owl:NegativePropertyAssertion>
<owl:targetValue> <rdfs:range> <rdfs:Literal>
<owl:topDataProperty> <rdf:type> <owl:DatatypeProperty>
<owl:topDataProperty> <rdfs:domain> <owl:Thing>
<owl:topDataProperty> <rdfs:range> <rdfs:Literal>
<owl:topObjectProperty> <rdf:type> <rdf:ObjectProperty>
<owl:topObjectProperty> <rdfs:domain> <owl:Thing>
<owl:topObjectProperty> <rdfs:range> <owl:Thing>
<owl:unionOf> <rdf:type> <rdf:Property>
<owl:unionOf> <rdfs:domain> <rdfs:Class>
<owl:unionOf> <rdfs:range> <rdf:List>
<owl:versionInfo> <rdf:type> <owl:AnnotationProperty>
<owl:versionInfo> <rdfs:domain> <rdfs:Resource>
<owl:versionInfo> <rdfs:range> <rdfs:Resource>
<owl:versionIRI> <rdf:type> <owl:OntologyProperty>
<owl:versionIRI> <rdfs:domain> <owl:Ontology>
<owl:versionIRI> <rdfs:range> <owl:Ontology>
<owl:withRestrictions> <rdf:type> <rdf:Property>
<owl:withRestrictions> <rdfs:domain> <rdfs:Datatype>
<owl:withRestrictions> <rdfs:range> <rdf:List>
// Table 6.3: Axiomatic Triples for the Datatypes of the OWL 2 RDF-Based Semantics
<xsd:anyURI> <rdf:type> <rdfs:Datatype>
<xsd:anyURI> <rdfs:subClassOf> <rdfs:Literal>
<xsd:base64Binary> <rdf:type> <rdfs:Datatype>
<xsd:base64Binary> <rdfs:subClassOf> <rdfs:Literal>
<xsd:boolean> <rdf:type> <rdfs:Datatype>
<xsd:boolean> <rdfs:subClassOf> <rdfs:Literal>
<xsd:byte> <rdf:type> <rdfs:Datatype>
<xsd:byte> <rdfs:subClassOf> <rdfs:Literal>
<xsd:dateTime> <rdf:type> <rdfs:Datatype>
<xsd:dateTime> <rdfs:subClassOf> <rdfs:Literal>
<xsd:dateTimeStamp> <rdf:type> <rdfs:Datatype>
<xsd:dateTimeStamp> <rdfs:subClassOf> <rdfs:Literal>
<xsd:decimal> <rdf:type> <rdfs:Datatype>
<xsd:decimal> <rdfs:subClassOf> <rdfs:Literal>
<xsd:double> <rdf:type> <rdfs:Datatype>
<xsd:double> <rdfs:subClassOf> <rdfs:Literal>
<xsd:float> <rdf:type> <rdfs:Datatype>
<xsd:float> <rdfs:subClassOf> <rdfs:Literal>
<xsd:hexBinary> <rdf:type> <rdfs:Datatype>
<xsd:hexBinary> <rdfs:subClassOf> <rdfs:Literal>
<xsd:int> <rdf:type> <rdfs:Datatype>
<xsd:int> <rdfs:subClassOf> <rdfs:Literal>
<xsd:integer> <rdf:type> <rdfs:Datatype>
<xsd:integer> <rdfs:subClassOf> <rdfs:Literal>
<xsd:language> <rdf:type> <rdfs:Datatype>
<xsd:language> <rdfs:subClassOf> <rdfs:Literal>
<xsd:long> <rdf:type> <rdfs:Datatype>
<xsd:long> <rdfs:subClassOf> <rdfs:Literal>
<xsd:Name> <rdf:type> <rdfs:Datatype>
<xsd:Name> <rdfs:subClassOf> <rdfs:Literal>
<xsd:NCName> <rdf:type> <rdfs:Datatype>
<xsd:NCName> <rdfs:subClassOf> <rdfs:Literal>
<xsd:negativeInteger> <rdf:type> <rdfs:Datatype>
<xsd:negativeInteger> <rdfs:subClassOf> <rdfs:Literal>
<xsd:NMTOKEN> <rdf:type> <rdfs:Datatype>
<xsd:NMTOKEN> <rdfs:subClassOf> <rdfs:Literal>
<xsd:nonNegativeInteger> <rdf:type> <rdfs:Datatype>
<xsd:nonNegativeInteger> <rdfs:subClassOf> <rdfs:Literal>
<xsd:nonPositiveInteger> <rdf:type> <rdfs:Datatype>
<xsd:nonPositiveInteger> <rdfs:subClassOf> <rdfs:Literal>
<xsd:normalizedString> <rdf:type> <rdfs:Datatype>
<xsd:normalizedString> <rdfs:subClassOf> <rdfs:Literal>
<rdf:PlainLiteral> <rdf:type> <rdfs:Datatype>
<rdf:PlainLiteral> <rdfs:subClassOf> <rdfs:Literal>
<xsd:positiveInteger> <rdf:type> <rdfs:Datatype>
<xsd:positiveInteger> <rdfs:subClassOf> <rdfs:Literal>
<owl:rational> <rdf:type> <rdfs:Datatype>
<owl:rational> <rdfs:subClassOf> <rdfs:Literal>
<owl:real> <rdf:type> <rdfs:Datatype>
<owl:real> <rdfs:subClassOf> <rdfs:Literal>
<xsd:short> <rdf:type> <rdfs:Datatype>
<xsd:short> <rdfs:subClassOf> <rdfs:Literal>
<xsd:string> <rdf:type> <rdfs:Datatype>
<xsd:string> <rdfs:subClassOf> <rdfs:Literal>
<xsd:token> <rdf:type> <rdfs:Datatype>
<xsd:token> <rdfs:subClassOf> <rdfs:Literal>
<xsd:unsignedByte> <rdf:type> <rdfs:Datatype>
<xsd:unsignedByte> <rdfs:subClassOf> <rdfs:Literal>
<xsd:unsignedInt> <rdf:type> <rdfs:Datatype>
<xsd:unsignedInt> <rdfs:subClassOf> <rdfs:Literal>
<xsd:unsignedLong> <rdf:type> <rdfs:Datatype>
<xsd:unsignedLong> <rdfs:subClassOf> <rdfs:Literal>
<xsd:unsignedShort> <rdf:type> <rdfs:Datatype>
<xsd:unsignedShort> <rdfs:subClassOf> <rdfs:Literal>
<rdf:XMLLiteral> <rdf:type> <rdfs:Datatype>
<rdf:XMLLiteral> <rdfs:subClassOf> <rdfs:Literal>
// Table 6.4: Axiomatic Triples for the Facets of the OWL 2 RDF-Based Semantics
<rdf:langRange> <rdf:type> <owl:DatatypeProperty>
<rdf:langRange> <rdfs:domain> <rdfs:Resource>
<rdf:langRange> <rdfs:range> <rdfs:Literal>
<xsd:length> <rdf:type> <owl:DatatypeProperty>
<xsd:length> <rdfs:domain> <rdfs:Resource>
<xsd:length> <rdfs:range> <rdfs:Literal>
<xsd:maxExclusive> <rdf:type> <owl:DatatypeProperty>
<xsd:maxExclusive> <rdfs:domain> <rdfs:Resource>
<xsd:maxExclusive> <rdfs:range> <rdfs:Literal>
<xsd:maxInclusive> <rdf:type> <owl:DatatypeProperty>
<xsd:maxInclusive> <rdfs:domain> <rdfs:Resource>
<xsd:maxInclusive> <rdfs:range> <rdfs:Literal>
<xsd:maxLength> <rdf:type> <owl:DatatypeProperty>
<xsd:maxLength> <rdfs:domain> <rdfs:Resource>
<xsd:maxLength> <rdfs:range> <rdfs:Literal>
<xsd:minExclusive> <rdf:type> <owl:DatatypeProperty>
<xsd:minExclusive> <rdfs:domain> <rdfs:Resource>
<xsd:minExclusive> <rdfs:range> <rdfs:Literal>
<xsd:minInclusive> <rdf:type> <owl:DatatypeProperty>
<xsd:minInclusive> <rdfs:domain> <rdfs:Resource>
<xsd:minInclusive> <rdfs:range> <rdfs:Literal>
<xsd:minLength> <rdf:type> <owl:DatatypeProperty>
<xsd:minLength> <rdfs:domain> <rdfs:Resource>
<xsd:minLength> <rdfs:range> <rdfs:Literal>
<xsd:pattern> <rdf:type> <owl:DatatypeProperty>
<xsd:pattern> <rdfs:domain> <rdfs:Resource>
<xsd:pattern> <rdfs:range> <rdfs:Literal>
// Table 6.5: Additional Axiomatic Triples for Classes and Properties of the RDFS Vocabulary
// <rdfs:Class> <rdfs:subClassOf> <owl:Class>
<rdfs:comment> <rdf:type> <owl:AnnotationProperty>
<rdfs:comment> <rdfs:domain> <rdfs:Resource>
<rdfs:comment> <rdfs:range> <rdfs:Literal>
// <rdfs:Datatype> <rdfs:subClassOf> <owl:DataRange>
<rdfs:isDefinedBy> <rdf:type> <owl:AnnotationProperty>
<rdfs:isDefinedBy> <rdfs:domain> <rdfs:Resource>
<rdfs:isDefinedBy> <rdfs:range> <rdfs:Resource>
<rdfs:label> <rdf:type> <owl:AnnotationProperty>
<rdfs:label> <rdfs:domain> <rdfs:Resource>
<rdfs:label> <rdfs:range> <rdfs:Literal>
<rdfs:Literal> <rdf:type> <rdfs:Datatype>
// <rdf:Property> <rdfs:subClassOf> <owl:ObjectProperty>
// <rdfs:Resource> <rdfs:subClassOf> <owl:Thing>
<rdfs:seeAlso> <rdf:type> <owl:AnnotationProperty>
<rdfs:seeAlso> <rdfs:domain> <rdfs:Resource>
<rdfs:seeAlso> <rdfs:range> <rdfs:Resource>
// ========================================================================
// OWL2 RL - Axioms about properties
// ========================================================================
// rule: prp_ap
// ------------
<rdfs:label> <rdf:type> <owl:AnnotationProperty>
<rdfs:comment> <rdf:type> <owl:AnnotationProperty>
<rdfs:seeAlso> <rdf:type> <owl:AnnotationProperty>
<rdfs:isDefinedBy> <rdf:type> <owl:AnnotationProperty>
<owl:deprecated> <rdf:type> <owl:AnnotationProperty>
<owl:versionInfo> <rdf:type> <owl:AnnotationProperty>
<owl:priorVersion> <rdf:type> <owl:AnnotationProperty>
<owl:backwardCompatibleWith> <rdf:type> <owl:AnnotationProperty>
<owl:incompatibleWith> <rdf:type> <owl:AnnotationProperty>
// ========================================================================
// OWL2 RL - Axioms about classes
// ========================================================================
// rule: cls_thing
// ---------------
<owl:Thing> <rdf:type> <owl:Class>
// rule: cls_nothing1
// ------------------
<owl:Nothing> <rdf:type> <owl:Class>
// ========================================================================
// OWL2 RL - Axioms about datatypes
// ========================================================================
// rule: dt-type1
// --------------
<rdf:PlainLiteral> <rdf:type> <rdfs:Datatype>
<rdf:XMLLiteral> <rdf:type> <rdfs:Datatype>
<rdfs:Literal> <rdf:type> <rdfs:Datatype>
<xsd:decimal> <rdf:type> <rdfs:Datatype>
<xsd:integer> <rdf:type> <rdfs:Datatype>
<xsd:nonNegativeInteger> <rdf:type> <rdfs:Datatype>
<xsd:nonPositiveInteger> <rdf:type> <rdfs:Datatype>
<xsd:positiveInteger> <rdf:type> <rdfs:Datatype>
<xsd:negativeInteger> <rdf:type> <rdfs:Datatype>
<xsd:long> <rdf:type> <rdfs:Datatype>
<xsd:int> <rdf:type> <rdfs:Datatype>
<xsd:short> <rdf:type> <rdfs:Datatype>
<xsd:byte> <rdf:type> <rdfs:Datatype>
<xsd:unsignedLong> <rdf:type> <rdfs:Datatype>
<xsd:unsignedInt> <rdf:type> <rdfs:Datatype>
<xsd:unsignedShort> <rdf:type> <rdfs:Datatype>
<xsd:unsignedByte> <rdf:type> <rdfs:Datatype>
<xsd:float> <rdf:type> <rdfs:Datatype>
<xsd:double> <rdf:type> <rdfs:Datatype>
<xsd:string> <rdf:type> <rdfs:Datatype>
<xsd:normalizedString> <rdf:type> <rdfs:Datatype>
<xsd:token> <rdf:type> <rdfs:Datatype>
<xsd:language> <rdf:type> <rdfs:Datatype>
<xsd:Name> <rdf:type> <rdfs:Datatype>
<xsd:NCName> <rdf:type> <rdfs:Datatype>
<xsd:NMTOKEN> <rdf:type> <rdfs:Datatype>
<xsd:boolean> <rdf:type> <rdfs:Datatype>
<xsd:hexBinary> <rdf:type> <rdfs:Datatype>
<xsd:base64Binary> <rdf:type> <rdfs:Datatype>
<xsd:anyURI> <rdf:type> <rdfs:Datatype>
<xsd:dateTime> <rdf:type> <rdfs:Datatype>
<xsd:dateTimeStamp> <rdf:type> <rdfs:Datatype>
}
Rules
{
// ========================================================================
// The Semantics of Equality
// ========================================================================
//CHECK
/* The semantics is implemented internally in the engine*/
Id: eq_ref
s p o [Constraint p != <owl:sameAs>]
-------------------------------
s <owl:sameAs> s
p <owl:sameAs> p
o <owl:sameAs> o
/*
Id: eq_sym
s <owl:sameAs> o [Constraint s != o]
-------------------------------
o <owl:sameAs> s
Id: eq_trans
x <owl:sameAs> y [Constraint x != y]
y <owl:sameAs> z [Constraint y != z]
-------------------------------
x <owl:sameAs> z
Id: eq_rep_s
x <owl:sameAs> y [Constraint x != y]
x p o
-------------------------------
y p o
Id: eq_rep_p
x <owl:sameAs> y [Constraint x != y]
s x o
-------------------------------
s y o
Id: eq_rep_o
x <owl:sameAs> y [Constraint x != y]
s p x
-------------------------------
s p y
*/
Consistency: eq_diff1
x <owl:sameAs> y
x <owl:differentFrom> y
-------------------------------
/*
Consistency: eq_diff2
T(?x, rdf:type, owl:AllDifferent)
T(?x, owl:members, ?y)
LIST[?y, ?z1, ..., ?zn]
T(?zi, owl:sameAs, ?zj) // for each 1 <= i < j <= n
-------------------------------
*/
/*
Consistency: eq_diff3
T(?x, rdf:type, owl:AllDifferent)
T(?x, owl:distinctMembers, ?y)
LIST[?y, ?z1, ..., ?zn]
T(?zi, owl:sameAs, ?zj) // for each 1 <= i < j <= n
-------------------------------
*/
Id: owl_allDiff1
x <rdf:type> <owl:AllDifferent>
x <owl:members> y
-------------------------------------
x <onto:_distinct> y [Context <onto:_allDiff>]
Id: owl_allDiff2
x <rdf:type> <owl:AllDifferent>
x <owl:distinctmembers> y
-------------------------------------
x <onto:_distinct> y [Context <onto:_allDiff>]
Id: owl_allDiff3
x <onto:_distinct> m [Context <onto:_allDiff>]
m <rdf:rest> n [Constraint n != <rdf:nil>]
-------------------------------
x <onto:_distinct> n [Context <onto:_allDiff>]
Consistency: owl_allDiff
x <onto:_distinct> m [Context <onto:_allDiff>]
x <onto:_distinct> n [Context <onto:_allDiff>]
m <rdf:first> i
n <rdf:first> j
i <owl:sameAs> j
-------------------------------
// ========================================================================
// The Semantics of Axioms about Properties
// ========================================================================
// Id: prp_ap
// See the axiomatic triples in the Axioms section.
Id: prp_dom
p <rdfs:domain> c
x p y
-------------------------------
x <rdf:type> c
Id: prp_rng
p <rdfs:range> c
x p y
-------------------------------
y <rdf:type> c
Id: prp_fp
p <rdf:type> <owl:FunctionalProperty>
x p y1 [Constraint y1 != y2]
x p y2 [Cut]
-------------------------------
y1 <owl:sameAs> y2
Id: prp_ifp
p <rdf:type> <owl:InverseFunctionalProperty>
x1 p y [Constraint x1 != x2]
x2 p y [Cut]
-------------------------------
x1 <owl:sameAs> x2
Consistency: prp_irp
p <rdf:type> <owl:IrreflexiveProperty>
x p x
-------------------------------
Id: prp_symp
p <rdf:type> <owl:SymmetricProperty>
x p y
-------------------------------
y p x
Consistency: prp_asyp
p <rdf:type> <owl:AsymmetricProperty>
x p y
y p x [Cut]
-------------------------------
Id: prp_trp
p <rdf:type> <owl:TransitiveProperty>
x p y
y p z
-------------------------------
x p z
Id: prp_spo1
p1 <rdfs:subPropertyOf> p2
x p1 y
-------------------------------
x p2 y
/*
--------
prp_spo2
--------
This is the rule as shown on the OWL2 RL page:
T(?p, owl:propertyChainAxiom, ?x)
LIST[?x, ?p1, ..., ?pn]
T(?u1, ?p1, ?u2)
T(?u2, ?p2, ?u3)
...
T(?un, ?pn, ?un+1)
-------------------------------
T(?u1, ?p, ?un+1)
The following implementation uses 3 rules.
*/
Id: prp_spo2_1
p <owl:propertyChainAxiom> pc
start pc last [Context <onto:_checkChain>]
----------------------------
start p last
Id: prp_spo2_2
pc <rdf:first> p
pc <rdf:rest> t [Constraint t != <rdf:nil>]
start p next
next t last [Context <onto:_checkChain>]
----------------------------
start pc last [Context <onto:_checkChain>]
Id: prp_spo2_3
pc <rdf:first> p
pc <rdf:rest> <rdf:nil>
start p last
----------------------------
start pc last [Context <onto:_checkChain>]
Id: prp_eqp1
p1 <owl:equivalentProperty> p2
x p1 y
-------------------------------
x p2 y
Id: prp_eqp2
p1 <owl:equivalentProperty> p2
x p2 y
-------------------------------
x p1 y
Consistency: prp_pdw
p1 <owl:propertyDisjointWith> p2
x p1 y
x p2 y
-------------------------------
/*
Consistency: prp_adp
T(?x, rdf:type, owl:AllDisjointProperties)
T(?x, owl:members, ?y)
LIST[?y, ?p1, ..., ?pn]
T(?u, ?pi, ?v) // for each 1 <= i < j <= n
T(?u, ?pj, ?v)
-------------------------------
*/
Id: owl_allDisjProp1
x <rdf:type> <owl:AllDisjointProperties>
x <owl:members> m
-------------------------------
x <onto:_AllDisjointProperties> m [Context <onto:_owl_allDisjProp>]
Id: owl_allDisjProp2
x <onto:_AllDisjointProperties> m [Context <onto:_owl_allDisjProp>]
m <rdf:rest> n [Constraint n != <rdf:nil>]
-------------------------------
x <onto:_AllDisjointProperties> n [Context <onto:_owl_allDisjProp>]
Id: owl_allDisjProp3
x <onto:_AllDisjointProperties> m [Context <onto:_owl_allDisjProp>]
x <onto:_AllDisjointProperties> n [Context <onto:_owl_allDisjProp>]
m <rdf:first> i
n <rdf:first> j [Constraint j != i]
-------------------------------
i <owl:propertyDisjointWith> j
Id: prp_inv1
p1 <owl:inverseOf> p2
x p1 y
-------------------------------
y p2 x
Id: prp_inv2
p1 <owl:inverseOf> p2
x p2 y
-------------------------------
y p1 x
/*
-------
prp_key
-------
This is the rule as shown on the OWL2 RL page:
T(?c, owl:hasKey, ?u)
LIST[?u, ?p1, ..., ?pn]
T(?x, rdf:type, ?c)
T(?x, ?p1, ?z1)
...
T(?x, ?pn, ?zn)
T(?y, rdf:type, ?c)
T(?y, ?p1, ?z1)
...
T(?y, ?pn, ?zn)
-------------------------------
T(?x, owl:sameAs, ?y)
The following implementation uses 3 rules.
*/
Id: prp_key_1 // final conclusion
c <owl:hasKey> u
x u y [Context <onto:_sameKey>]
-------------------------------
x <owl:sameAs> y
Id: prp_key_2 // recursive step towards top of the list
u <rdf:first> key
u <rdf:rest> t
x t y [Context <onto:_sameKey>]
x key v [Constraint x != y]
y key v [Cut]
-------------------------------
x u y [Context <onto:_sameKey>]
Id: prp_key_3_bottom // match bottom of the list
c <owl:hasKey> u1
x <rdf:type> c
y <rdf:type> c [Cut]
u <rdf:first> key
u <rdf:rest> <rdf:nil>
x key v [Constraint x != y]
y key v [Cut]
-------------------------------
x u y [Context <onto:_sameKey>]
Consistency: prp_npa1
x <owl:sourceIndividual> i1
x <owl:assertionProperty> p
x <owl:targetIndividual> i2
i1 p i2
-------------------------------
Consistency: prp_npa2
x <owl:sourceIndividual> i
x <owl:assertionProperty> p
x <owl:targetValue> lt
i p lt
-------------------------------
// ========================================================================
// The Semantics of Classes
// ========================================================================
// Id: cls_thing
// (See the axiomatic triples in the Axioms section)
// Id: cls_nothing1
// (See the axiomatic triples in the Axioms section)
Consistency: cls_nothing2
x <rdf:type> <owl:Nothing>
-------------------------------
/*
-------------------
cls_int1 & cls_int2
-------------------
These rules as shown in the OWL2 RL semantics page:
Id: cls_int1
T(?c, owl:intersectionOf, ?x)
LIST[?x, ?c1, ..., ?cn]
T(?y, rdf:type, ?c1)
T(?y, rdf:type, ?c2)
...
T(?y, rdf:type, ?cn)
-------------------------------
T(?y, rdf:type, ?c)
Id: cls_int2
T(?c, owl:intersectionOf, ?x)
LIST[?x, ?c1, ..., ?cn]
T(?y, rdf:type, ?c)
-------------------------------
T(?y, rdf:type, ?c1)
T(?y, rdf:type, ?c2)
...
T(?y, rdf:type, ?cn)
The are achieved with the following pair of rules:
*/
Id: owl_typeByIntersect_1
i <onto:_allTypes> b [Context <onto:_typeByInt>]
z <owl:intersectionOf> b
--------------------------------
i <rdf:type> z
Id: owl_typeByIntersect_2
b <rdf:first> c
b <rdf:rest> <rdf:nil>
i <rdf:type> c
--------------------------------
i <onto:_allTypes> b [Context <onto:_typeByInt>]
Id: owl_typeByIntersect_3
b <rdf:first> c
b <rdf:rest> b1
i <onto:_allTypes> b1 [Context <onto:_typeByInt>]
i <rdf:type> c
--------------------------------
i <onto:_allTypes> b [Context <onto:_typeByInt>]
/*
This rule is redundant and follows from the other union rule plus subclass rules
Id: cls_uni
T(?c, owl:unionOf, ?x)
LIST[?x, ?c1, ..., ?cn]
T(?y, rdf:type, ?ci) // for each 1 <= i <= n
-------------------------------
T(?y, rdf:type, ?c)
*/
Consistency: cls_com
c1 <owl:complementOf> c2
x <rdf:type> c1
x <rdf:type> c2
-------------------------------
Id: cls_svf1
x <owl:someValuesFrom> y
x <owl:onProperty> p
u p v
v <rdf:type> y
-------------------------------
u <rdf:type> x
Id: cls_svf2
x <owl:someValuesFrom> <owl:Thing>
x <owl:onProperty> p
u p v
-------------------------------
u <rdf:type> x
Id: cls_avf
x <owl:allValuesFrom> y
x <owl:onProperty> p
u <rdf:type> x
u p v
-------------------------------
v <rdf:type> y
Id: cls_hv1
x <owl:hasValue> y
x <owl:onProperty> p
u <rdf:type> x
-------------------------------
u p y
Id: cls_hv2
x <owl:hasValue> y
x <owl:onProperty> p
u p y
-------------------------------
u <rdf:type> x
Consistency: cls_maxc1
x <owl:maxCardinality> "0"^^xsd:nonNegativeInteger
x <owl:onProperty> p
u <rdf:type> x
u p y
-------------------------------
Id: cls_maxc2
x <owl:maxCardinality> "1"^^xsd:nonNegativeInteger
x <owl:onProperty> p
u <rdf:type> x
u p y1
u p y2
-------------------------------
y1 <owl:sameAs> y2
Consistency: cls_maxqc1
x <owl:maxQualifiedCardinality> "0"^^xsd:nonNegativeInteger
x <owl:onProperty> p
x <owl:onClass> c
u <rdf:type> x
u p y
y <rdf:type> c
-------------------------------
Consistency: cls_maxqc2
x <owl:maxQualifiedCardinality> "0"^^xsd:nonNegativeInteger
x <owl:onProperty> p
x <owl:onClass> <owl:Thing>
u <rdf:type> x
u p y
-------------------------------
Id: cls_maxqc3
x <owl:maxQualifiedCardinality> "1"^^xsd:nonNegativeInteger
x <owl:onProperty> p
x <owl:onClass> c
u <rdf:type> x
u p y1
y1 <rdf:type> c
u p y2 [Cut]
y2 <rdf:type> c [Cut]
-------------------------------
y1 <owl:sameAs> y2 [Constraint y1 != y2]
Id: cls_maxqc4
x <owl:maxQualifiedCardinality> "1"^^xsd:nonNegativeInteger
x <owl:onProperty> p
x <owl:onClass> <owl:Thing>
u <rdf:type> x
u p y1 [Cut]
u p y2 [Constraint y1 != y2]
-------------------------------
y1 <owl:sameAs> y2
/*
------
cls_oo
------
This is how the rule appears in the OWL2 RL page:
T(?c, owl:oneOf, ?x)
LIST[?x, ?y1, ..., ?yn]
-------------------------------
T(?y1, rdf:type, ?c)
...
T(?yn, rdf:type, ?c)
It is achieved with the following pair of rules:
*/
// Part 1 of cls_oo
Id: cls_oo_1
c <owl:oneOf> x
------------------
c <onto:_oneOf> x [Context <onto:_cls_oo>]
// Part 2 of cls_oo
Id: cls_oo_2
c <onto:_oneOf> x [Context <onto:_cls_oo>]
x <rdf:first> y
x <rdf:rest> z
-------------------------------
y <rdf:type> c
c <onto:_oneOf> z [Context <onto:_cls_oo>][Constraint z != <rdf:nil>]
// ========================================================================
// The Semantics of Class Axioms
// ========================================================================
Id:cax_sco
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
x <rdf:type> c1
-------------------------------
x <rdf:type> c2
Id: cax_eqc1
c1 <owl:equivalentClass> c2 [Constraint c1 != c2 ]
x <rdf:type> c1
-------------------------------
x <rdf:type> c2
Id: cax_eqc2
c1 <owl:equivalentClass> c2 [Constraint c1 != c2 ]
x <rdf:type> c2
-------------------------------
x <rdf:type> c1
Consistency: cax_dw
c1 <owl:disjointWith> c2
x <rdf:type> c1
x <rdf:type> c2
-------------------------------
/*
Consistency: cax_adc
T(?x, rdf:type, owl:AllDisjointClasses)
T(?x, owl:members, ?y)
LIST[?y, ?c1, ..., ?cn]
T(?z, rdf:type, ?ci)
T(?z, rdf:type, ?cj)
-------------------------------
*/
Id: owl_allDisjClasses1
x <rdf:type> <owl:AllDisjointClasses>
x <owl:members> m
-------------------------------
x <onto:_AllDisjointClasses> m [Context <onto:_owl_allDisjClasses>]
Id: owl_allDisjClasses2
x <onto:_AllDisjointClasses> m [Context <onto:_owl_allDisjClasses>]
m <rdf:rest> n [Constraint n != <rdf:nil>]
---------------------------------
x <onto:_AllDisjointClasses> n [Context <onto:_owl_allDisjClasses>]
Id: owl_allDisjClasses3
x <onto:_AllDisjointClasses> m [Context <onto:_owl_allDisjClasses>]
x <onto:_AllDisjointClasses> n [Context <onto:_owl_allDisjClasses>]
m <rdf:first> i
n <rdf:first> j [Constraint j != i]
-------------------------------
i <owl:disjointWith> j
// ========================================================================
// The Semantics of Datatypes
// ========================================================================
// Id: dt-type1
// (See the axiomatic triples in the Axioms section)
// These are not implemented (and probably not implementable)
// dt-type2
// dt-eq
// dt-diff
// dt-not-type
// ========================================================================
// The Semantics of Schema Vocabulary
// ========================================================================
Id: scm_cls
c <rdf:type> <owl:Class>
-------------------------------
c <rdfs:subClassOf> c
c <owl:equivalentClass> c
c <rdfs:subClassOf> <owl:Thing>
<owl:Nothing> <rdfs:subClassOf> c
Id: scm_sco
c1 <rdfs:subClassOf> c2
c2 <rdfs:subClassOf> c3
-------------------------------
c1 <rdfs:subClassOf> c3
Id: scm_eqc1
c1 <owl:equivalentClass> c2 [Constraint c1 != c2 ]
-------------------------------
c1 <rdfs:subClassOf> c2
c2 <rdfs:subClassOf> c1
Id: scm_eqc2
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
c2 <rdfs:subClassOf> c1
-------------------------------
c1 <owl:equivalentClass> c2
Id: scm_op
p <rdf:type> <owl:ObjectProperty>
-------------------------------
p <rdfs:subPropertyOf> p
p <owl:equivalentProperty> p
Id: scm_dp
p <rdf:type> <owl:DatatypeProperty>
-------------------------------
p <rdfs:subPropertyOf> p
p <owl:equivalentProperty> p
Id: scm_spo
p1 <rdfs:subPropertyOf> p2
p2 <rdfs:subPropertyOf> p3
-------------------------------
p1 <rdfs:subPropertyOf> p3
Id: scm_eqp1
p1 <owl:equivalentProperty> p2 [Constraint p1 != p2 ]
-------------------------------
p1 <rdfs:subPropertyOf> p2
p2 <rdfs:subPropertyOf> p1
Id: scm_eqp2
p1 <rdfs:subPropertyOf> p2 [Constraint p1 != p2 ]
p2 <rdfs:subPropertyOf> p1
-------------------------------
p1 <owl:equivalentProperty> p2
Id: scm_dom1
p <rdfs:domain> c1
c1 <rdfs:subClassOf> c2
-------------------------------
p <rdfs:domain> c2
Id: scm_dom2
p2 <rdfs:domain> c
p1 <rdfs:subPropertyOf> p2
-------------------------------
p1 <rdfs:domain> c
Id: scm_rng1
p <rdfs:range> c1
c1 <rdfs:subClassOf> c2
-------------------------------
p <rdfs:range> c2
Id: scm_rng2
p2 <rdfs:range> c
p1 <rdfs:subPropertyOf> p2
-------------------------------
p1 <rdfs:range> c
Id: scm_hv
c1 <owl:hasValue> i
c1 <owl:onProperty> p1
c2 <owl:hasValue> i
c2 <owl:onProperty> p2
p1 <rdfs:subPropertyOf> p2 [Constraint p1 != p2 ]
-------------------------------
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
Id: scm_svf1
c1 <owl:someValuesFrom> y1
c1 <owl:onProperty> p
c2 <owl:someValuesFrom> y2
c2 <owl:onProperty> p
y1 <rdfs:subClassOf> y2 [Constraint y1 != y2 ]
-------------------------------
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
Id: scm_svf2
c1 <owl:someValuesFrom> y
c1 <owl:onProperty> p1
c2 <owl:someValuesFrom> y
c2 <owl:onProperty> p2
p1 <rdfs:subPropertyOf> p2 [Constraint p1 != p2 ]
-------------------------------
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
Id: scm_avf1
c1 <owl:allValuesFrom> y1
c1 <owl:onProperty> p
c2 <owl:allValuesFrom> y2
c2 <owl:onProperty> p
y1 <rdfs:subClassOf> y2 [Constraint y1 != y2 ]
-------------------------------
c1 <rdfs:subClassOf> c2 [Constraint c1 != c2 ]
Id: scm_avf2
c1 <owl:allValuesFrom> y
c1 <owl:onProperty> p1
c2 <owl:allValuesFrom> y
c2 <owl:onProperty> p2
p1 <rdfs:subPropertyOf> p2 [Constraint p1 != p2 ]
-------------------------------
c2 <rdfs:subClassOf> c1 [Constraint c1 != c2 ]
/*
-------
scm_int
-------
This is the scm_int rule as shown on the OWL2 RL page:
T(?c, owl:intersectionOf, ?x)
LIST[?x, ?c1, ..., ?cn]
-------------------------------
T(?c, rdfs:subClassOf, ?c1)
T(?c, rdfs:subClassOf, ?c2)
...
T(?c, rdfs:subClassOf, ?cn)
It is achieved with the following pair of rules:
*/
Id: scm_int_1
c <owl:intersectionOf> x
-------------------------------
c <onto:_interOf> x [Context <onto:scm_int>]
Id: scm_int_2
c <onto:_interOf> x [Context <onto:scm_int>]
x <rdf:first> y
x <rdf:rest> z
-------------------------------
c <rdfs:subClassOf> y
c <onto:_interOf> z [Context <onto:scm_int>]
/*
-------
scm_uni
-------
This is the scm_uni rule as shown on the OWL2 RL page:
T(?c, owl:unionOf, ?x)
LIST[?x, ?c1, ..., ?cn]
-------------------------------
T(?c1, rdfs:subClassOf, ?c)
T(?c2, rdfs:subClassOf, ?c)
...
T(?cn, rdfs:subClassOf, ?c)
It is achieved with the following 2 rules:
*/
Id: scm_uni_1
a <onto:_unionOf> m [Context <onto:_scm_uni>]
m <rdf:first> c
m <rdf:rest> d
-------------------------------
c <rdfs:subClassOf> a
a <onto:_unionOf> d [Context <onto:_scm_uni>]
Id: scm_uni_2
a <owl:unionOf> m
-------------------------------
a <onto:_unionOf> m [Context <onto:_scm_uni>]
// ========================================================================
// Custom rules for UF-OKN
// ========================================================================
Id: ufokn_c_assetCriticallyServes
x <ufokn_c:assetServes> y
x <ufokn_c:assetOfTypeRequiredBy> y
-------------------------------
x <ufokn_c:assetCriticallyServes> y
// x <ufokn_c:assetCriticallyServesTC> y
// Id: ufokn_c_assetCriticallyServesTC
// x <ufokn_c:assetCriticallyServesTC> y
// y <ufokn_c:assetCriticallyServesTC> z
// -------------------------------
// x <ufokn_c:assetCriticallyServesTC> z
}