owlvocabularyexplanationdeposit.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 722 行 · 第 1/5 页

			+ "<p>The class owl:Restriction is defined as a subclass of owl:Class. A restriction class should have exactly one triple linking the restriction to a particular property, using the  owl:onProperty property. The restriction class should also have exactly one triple that represents the value constraint c.q. cardinality constraint on the property under consideration, e.g., that the cardinality of the property is exactly 1.</p>",
					sources_Restriction, OWL_REF, null)
			);
			
			name = OWLVocabularyAdapter.OWL + "SymmetricProperty";
			URI [] sources_SymmProp = { new URI("http://www.w3.org/TR/owl-ref/#SymmetricProperty-def")};
			add( new OWLVocabularyExplanation( new URI(name), name,			
				"<p>A symmetric property is a property for which holds that if the pair (x,y) is an instance of P, then the pair (y,x) is also an instance of P. Syntactically, a property is defined as symmetric by making it an instance of the built-in OWL class owl:SymmetricProperty, a subclass of owl:ObjectProperty.</p>"
			+	"<p>A popular example of a symmetric property is the friendOf relation:</p><br>"
			+	"&lt;owl:SymmetricProperty rdf:ID=\"friendOf\"&gt;" + NL
			+ 	TAB +  "&lt;rdfs:domain rdf:resource=\"#Human\"/&gt;" + NL
			+ 	TAB+  "&lt;rdfs:range  rdf:resource=\"#Human\"/&gt;" + NL
			+ 	"&lt;/owl:SymmetricProperty&gt;" + NL
			+	"<p>The domain and range of a symmetric property are the same.</p>",
				sources_SymmProp, OWL_REF, null)
			);
			
			
			name = OWLVocabularyAdapter.OWL + "Thing";
			URI [] sources_thing = { new URI("http://www.w3.org/TR/owl-ref/#Thing-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
					"<p>Two OWL class identifiers are predefined, namely the classes  owl:Thing and  owl:Nothing. The class extension of owl:Thing is the set of all individuals. The class extension of owl:Nothing is the empty set. Consequently, every OWL class is a subclass of owl:Thing and owl:Nothing is a subclass of every class (for the meaning of the subclass relation, see rdfs:subClassOf).</p>",
					sources_thing, OWL_REF, null) 
			);	

			name = OWLVocabularyAdapter.OWL + "TransitiveProperty";
			URI [] sources_tranProp = { new URI("http://www.w3.org/TR/owl-ref/#TransitiveProperty-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,			
					"<p>When one defines a property P to be a transitive property, this means that if a pair (x,y) is an instance of P, and the pair (y,z) is also instance of P, then we can infer the the pair (x,z) is also an instance of P.</p>"
				+	"<p>Syntactically, a property is defined as being transitive by making it an instance of the the built-in OWL class owl:TransitiveProperty, which is defined as a subclass of owl:ObjectProperty.</p>"
				+	"<p>Typical examples of transitive properties are properties representing certain part-whole relations. For example, we might want to say that the subRegionOf property between regions is transitive:</p><br>"			
				+	"&lt;owl:TransitiveProperty rdf:ID=\"subRegionOf\"&gt;"+ NL
				+ 	TAB+ "&lt;rdfs:domain rdf:resource=\"#Region\"/&gt;"+ NL
				+ 	TAB +"&lt;rdfs:range  rdf:resource=\"#Region\"/&gt;"+ NL
				+	"&lt;/owl:TransitiveProperty&gt;" + NL
				+	"<p>From this an OWL reasoner should be able to derive that if ChiantiClassico, Tuscany and Italy are regions, and ChiantiClassico is a subregion of Tuscany, and Tuscany is a subregion of Italy, then ChiantiClassico is also a subregion of Italy.</p>"
				+	"<p>Note that because owl:TransitiveProperty is a subclass of owl:ObjectProperty, the following syntactic variant is equivalent to the example above:</p><br>"		
				+	"&lt;owl:ObjectProperty rdf:ID=\"subRegionOf\"&gt;"+ NL
				+ TAB +  "&lt;rdf:type rdf:resource=\"&amp;owl;TransitiveProperty\"/&gt;"+ NL
				+ TAB +  "&lt;rdfs:domain rdf:resource=\"#Region\"/&gt;"+ NL
				+ TAB +	 "&lt;rdfs:range  rdf:resource=\"#Region\"/&gt;"+ NL
				+	"&lt;/owl:ObjectProperty&gt;"+ NL
				+ "<p>NOTE: OWL DL requires that for a transitive property no local or global cardinality constraints should be declared on the property itself or its superproperties, nor on the inverse of the property or its superproperties.</p>",
					sources_tranProp, OWL_REF, null) 
			);				
			
			
			// OWL properties
			
			
			name = OWLVocabularyAdapter.OWL + "allValuesFrom";
			URI [] sources_AVF = { new URI("http://www.w3.org/TR/owl-ref/#allValuesFrom-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
					"<p>The value constraint owl:allValuesFrom is a built-in OWL property that links a restriction class to either a class description or a data range. A restriction containing an owl:allValuesFrom constraint is used to describe a class of all individuals for which all values of the property under consideration are either members of the class extension of the class description or are data values within the specified data range. In other words, it defines a class of individuals x for which holds that if the pair (x,y) is an instance of P (the property concerned), then y should be an instance of the class description or a value in the data range, respectively.</p>"
				+	"<p>A simple example:</p><br>"
				+ 	"&lt;owl:Restriction&gt;" + NL
				+	TAB+ "&lt;owl:onProperty rdf:resource=\"#hasParent\" /&gt;" + NL
				+	TAB+ "&lt;owl:allValuesFrom rdf:resource=\"#Human\"  /&gt;" + NL
				+	"&lt;/owl:Restriction&gt;"				
				+	"<p>This example describes an anonymous OWL class of all individuals for which the hasParent property only has values of class Human. Note that this class description does not state that the property always has values of this class; just that this is true for individuals that belong to the class extension of the anonymous restriction class.</p>"
				+	"<p>NOTE: In OWL Lite the only type of class description allowed as object of owl:allValuesFrom is a class name.</p>"
				+	"<p>An owl:allValuesFrom constraint is analogous to the universal (for-all) quantifier of Predicate logic - for each instance of the class that is being described, every value for P must fulfill the constraint. Also notice that the correspondence of owl:allValuesFrom with the universal quantifier means that an owl:allValuesFrom constraint for a property P is trivially satisfied for an individual that has no value for property P at all. To see why this is so, observe that the owl:allValuesFrom constraint demands that all values of P should be of type T, and if no such values exist, the constraint is trivially true.</p>",
				sources_AVF, OWL_REF, null) 
			);	
			
			name = OWLVocabularyAdapter.OWL + "backwardCompatibleWith";
			URI [] sources_BCW = { new URI("http://www.w3.org/TR/owl-ref/#backwardCompatibleWith-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
					"<p>An owl:backwardCompatibleWith statement contains a reference to another ontology. This identifies the specified ontology as a prior version of the containing ontology, and further indicates that it is backward compatible with it. In particular, this indicates that all identifiers from the previous version have the same intended interpretations in the new version. Thus, it is a hint to document authors that they can safely change their documents to commit to the new version (by simply updating namespace declarations and owl:imports statements to refer to the URL of the new version). If owl:backwardCompatibleWith is not declared for two versions, then compatibility should not be assumed.</p>"
				+	"<p>owl:backwardCompatibleWith has no meaning in the model theoretic semantics other than that given by the RDF(S) model theory.</p>"
				+	"<p>owl:backwardCompatibleWith is a built-in OWL property with the class owl:Ontology as its domain and range.</p>"
				+	"<p>NOTE: owl:backwardCompatibleWith is an instance of owl:OntologyProperty.</p>",
				sources_BCW, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "cardinality";
			URI [] sources_cardinality = { new URI("http://www.w3.org/TR/owl-ref/#cardinality-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
					"<p>The cardinality constraint owl:cardinality is a built-in OWL property that links a restriction class to a data value belonging to the range of the XML Schema datatype nonNegativeInteger. A restriction containing an owl:cardinality constraint describes a class of all individuals that have  exactly N semantically distinct values (individuals or data values) for the property concerned, where N is the value of the cardinality constraint. Syntactically, the cardinality constraint is represented as an RDF property element with the corresponding rdf:datatype attribute</p>"
				+	"<p>This construct is in fact redundant as it can always be replaced by a pair of matching owl:minCardinality and owl:maxCardinality constraints with the same value. It is included as a convenient shorthand for the user.</p>"
				+	"<p>The following example describes a class of individuals that have exactly two parents:</p><br>"
				+	"&lt;owl:Restriction&gt;" + NL
				+ 	TAB +  "&lt;owl:onProperty rdf:resource=\"#hasParent\" /&gt;" + NL
				+ 	TAB +  "&lt;owl:cardinality rdf:datatype=\"&amp;xsd;nonNegativeInteger\"&gt;2&lt;/owl:cardinality&gt;" + NL
				+  	"&lt;/owl:Restriction&gt;" +NL,
				sources_cardinality, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "complementOf";
			URI [] sources_compOf = { new URI("http://www.w3.org/TR/owl-ref/#complementOf-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,			
					"<p>An owl:complementOf property links a class to precisely one class description. An owl:complementOf statement describes a class for which the class extension contains exactly those individuals that do not belong to the class extension of the class description that is the object of the statement. owl:complementOf is analogous to logical negation: the class extension consists of those individuals that are NOT members of the class extension of the complement class.</p>"
				+	"<p>As an example of the use of complement, the expression \"not meat\" could be written as:</p><br>"
				+	"&lt;owl:Class&gt;"
				+	TAB+"&lt;owl:complementOf&gt;" + NL
				+	TAB+TAB+"&lt;owl:Class rdf:about=\"#Meat\"/&gt;" + NL
				+	TAB+"&lt;/owl:complementOf&gt;" + NL
				+	"&lt;/owl:Class&gt;"
				+	"<p>The extension of this class description contains all individuals that do not belong to the class Meat.</p>"
				+	"<p>NOTE: owl:complementOf is not part of OWL Lite.</p>",
					sources_compOf, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "differentFrom";
			URI [] sources_DiffFrom = { new URI("http://www.w3.org/TR/owl-ref/#differentFrom-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,	
					"<p>The built-in OWL owl:differentFrom property links an individual to an individual. An owl:differentFrom statement indicates that two URI references refer to different individuals.</p>"
				+	"<p>An example:</p><br>"
				+	"&lt;Opera rdf:ID=\"Don_Giovanni\"/&gt;" + NL
				+	"&lt;Opera rdf:ID=\"Nozze_di_Figaro\"&gt;" + NL
				+	TAB + "&lt;owl:differentFrom rdf:resource=\"#Don_Giovanni\"/&gt;" + NL
				+	"&lt;/Opera&gt;"
				+	"&lt;Opera rdf:ID=\"Cosi_fan_tutte\"&gt;" + NL
				+	TAB + "&lt;owl:differentFrom rdf:resource=\"#Don_Giovanni\"/&gt;"+ NL
				+	TAB + "&lt;owl:differentFrom rdf:resource=\"#Nozze_di_Figaro\"/&gt;" + NL
				+	"&lt;/Opera&gt;"
				+	"<p>This states that there are three different operas.</p>", 
				sources_DiffFrom, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "disjointWith";
			URI [] sources_DisjointWith = { new URI("http://www.w3.org/TR/owl-ref/#disjointWith-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
						"<p>A class axiom may also contain (multiple) owl:disjointWith statements. owl:disjointWith is a built-in OWL property with a class description as domain and range. Each owl:disjointWith statement asserts that the class extensions of the two class descriptions involved have no individuals in common. Like axioms with rdfs:subClassOf, declaring two classes to be disjoint is a partial definition: it imposes a necessary but not sufficient condition on the class.</p>"
					+	"<p>This is a popular example of class disjointness:</p><br>"
					+	"&lt;owl:Class rdf:about=\"#Man\"&gt;" + NL 
					+	TAB+"&lt;owl:disjointWith rdf:resource=\"#Woman\"/&gt;" + NL 
					+	"&lt;/owl:Class&gt;"
					+	"<p>Whether this is actually true is a matter for biologists to decide. The following example shows a common use of class disjointness in subclass hierarchies:</p><br>"
					+	"&lt;owl:Class rdf:about=\"#MusicDrama\"&gt;" + NL 
					+ 	TAB + "&lt;owl:equivalentClass&gt;" + NL 
					+ 	TAB + TAB + "&lt;owl:Class&gt;" + NL 
					+ 	TAB + TAB + TAB + "&lt;owl:unionOf rdf:parseType=\"Collection\"&gt;" + NL 
					+ 	TAB + TAB + TAB + TAB + "&lt;owl:Class rdf:about=\"#Opera\"/&gt;" + NL 
					+ 	TAB + TAB +TAB +TAB + "&lt;owl:Class rdf:about=\"#Operetta\"/&gt;" + NL 
					+ 	TAB + TAB + TAB +TAB + "&lt;owl:Class rdf:about=\"#Musical\"/&gt;" + NL 
					+	TAB + TAB + TAB +     "&lt;/owl:unionOf&gt;" + NL 
					+ 	TAB + TAB +   "&lt;/owl:Class&gt;" + NL 
					+ 	TAB +  "&lt;/owl:equivalentClass&gt;" + NL 
					+	"&lt;/owl:Class&gt;"+ NL
					+ 	"<br>"
					+	"&lt;owl:Class rdf:about=\"#Opera\"&gt;" + NL 
					+ 	TAB + "&lt;rdfs:subClassOf rdf:resource=\"#MusicDrama\"/&gt;" + NL 
					+ 	"&lt;/owl:Class&gt;" + NL 
					+ 	"<br>"