owlvocabularyexplanationdeposit.java

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

					+ 	"<owl:Class rdf:about=\"#Operetta\">"
					+ 	TAB + "<rdfs:subClassOf rdf:resource=\"#MusicDrama\"/>" + NL 
					+ 	TAB +	"<owl:disjointWith rdf:resource=\"#Opera\"/>" + NL 
					+ 	"</owl:Class>" + NL
					+ 	"<br>"
					+	"&lt;owl:Class rdf:about=\"#Musical\"&gt;" + NL 
					+ 	TAB + "&lt;rdfs:subClassOf rdf:resource=\"#MusicDrama\"/&gt;" + NL 
					+	TAB + "&lt;owl:disjointWith rdf:resource=\"#Opera\"/&gt;" + NL 
					+	TAB + "&lt;owl:disjointWith rdf:resource=\"#Operetta\"/&gt;" + NL 
					+	TAB + "&lt;/owl:Class&gt;"
					+	"<p>Here, owl:disjointWith statements are used together with owl:unionOf in order to define a set of mutually disjoint and complete subclasses of a superclass. In natural language: every MusicDrama is either an opera, an Operetta, or a Musical (the subclass partitioning is complete) and individuals belonging to one subclass, e.g., Opera, cannot belong to another subclass, e.g., Musical (disjoint or non-overlapping subclasses). This is a common modelling notion used in many data-modelling notations.</p>"
					+	"<p>NOTE: OWL Lite does not allow the use of owl:disjointWith.</p>",
					sources_DisjointWith, OWL_REF, null) 
			);
					
			name = OWLVocabularyAdapter.OWL + "distinctMembers";
			URI [] sources_distinctMembers = { new URI("http://www.w3.org/TR/owl-ref/#distinctMembers-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,			
					"<p>owl:AllDifferent. owl:AllDifferent is a special built-in OWL class, for which the property owl:distinctMembers  is defined, which links an instance of owl:AllDifferent to a list of individuals. The intended meaning of such a statement is that all individuals in the list are all different from each other.</p>"
				+	"<p>An example:</p> <br>"			
				+	"&lt;owl:AllDifferent&gt;" + NL
				+ 	TAB + "&lt;owl:distinctMembers rdf:parseType=\"Collection\"&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Don_Giovanni\"/&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Nozze_di_Figaro\"/&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Cosi_fan_tutte\"/&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Tosca\"/&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Turandot\"/&gt;" + NL
				+ 	TAB + TAB +"&lt;Opera rdf:about=\"#Salome\"/&gt;" + NL
				+ 	TAB +"&lt;/owl:distinctMembers&gt;" + NL
				+ 	"&lt;/owl:AllDifferent&gt;" + NL
				+	"<p>This states that these six URI references all point to different operas.</p>"+ NL
				+	"<p>NOTE: owl:distinctMembers is a special syntactical construct added for convenience and should always be used with an owl:AllDifferent individual as its subject.</p>"+ NL, 
				sources_distinctMembers, OWL_REF, null) 
			);
			
			
			name = OWLVocabularyAdapter.OWL + "equivalentClass";
			URI [] sources_equiClass = { new URI("http://www.w3.org/TR/owl-ref/#equivalentClass-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,		
					"<p>A class axiom may contain (multiple) owl:equivalentClass statements. owl:equivalentClass is a built-in property that links a class description to another class description. The meaning of such a class axiom is that the two class descriptions involved have the same class extension (i.e., both class extensions contain exactly the same set of individuals).</p>"
				+	"<p>In its simplest form, an equivalentClass axiom states the equivalence (in terms of their class extension) of two named classes. An example:</p><br>"
				+	"&lt;owl:Class rdf:about=\"#US_President\"&gt;" + NL
				+	TAB +"&lt;equivalentClass rdf:resource=\"#PrincipalResidentOfWhiteHouse\"/&gt;"+ NL
				+	"&lt;/owl:Class&gt;"
				+	"<p>NOTE: The use of owl:equivalentClass does not imply class equality. Class equality means that the classes have the same intensional meaning (denote the same concept). In the example above, the concept of \"President of the US\" is related to, but not equal to the concept of the principal resident of a certain estate. Real class equality can only be expressed with the owl:sameAs construct. As this requires treating classes as individuals, class equality can only be expressed in OWL Full.</p>",
					sources_equiClass, OWL_REF, null) 
			);
			

			name = OWLVocabularyAdapter.OWL + "equivalentProperty";
			URI [] sources_equiProp = { new URI("http://www.w3.org/TR/owl-ref/#equivalentProperty-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,				
					"<p>The owl:equivalentProperty construct can be used to state that two properties have the same property extension. Syntactically, owl:equivalentProperty is a built-in OWL property with rdf:Property as both its domain and range.</p>"
				+	"<p>NOTE: Property equivalence is not the same as property equality. Equivalent properties have the same \"values\" (i.e., the same property extension), but may have different intensional meaning (i.e., denote different concepts). Property equality should be expressed with the owl:sameAs construct. As this requires that properties are treated as individuals, such axioms are only allowed in OWL Full.</p>",
					sources_equiProp, OWL_REF, null) 
			);
				
			
			name = OWLVocabularyAdapter.OWL + "hasValue";
			URI [] sources_hasVal = { new URI("http://www.w3.org/TR/owl-ref/#hasValue-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,				
					"<p>The value constraint owl:hasValue is a built-in OWL property that links a restriction class to a value V, which can be either an individual or a data value. A restriction containing a owl:hasValue constraint describes a class of all individuals for which the property concerned has at least one value semantically equal to V (it may have other values as well).</p>"
				+	"<p>NOTE: for datatypes \"semantically equal\" means that the lexical representation of the literals maps to the same value. For individuals it means that they either have the same URI reference or are defined as being the same individual (see owl:sameAs).</p>"
				+	"<p>NOTE: the value constraint owl:hasValue is not included in OWL Lite.</p>"
				+	"<p>The following example describes the class of individuals who have the individual referred to as Clinton as their parent:</p><br>"
				+	"&lt;owl:Restriction&gt;" + NL
				+	TAB + "&lt;owl:onProperty rdf:resource=\"#hasParent\" /&gt;" + NL
				+	TAB + "&lt;owl:hasValue rdf:resource=\"#Clinton\" /&gt;" + NL
				+	"&lt;/owl:Restriction&gt;" + NL,
					sources_hasVal, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "imports";
			URI [] sources_imports = { new URI("http://www.w3.org/TR/owl-ref/#imports-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
					"<p>An owl:imports statement references another OWL ontology containing definitions, whose meaning is considered to be part of the meaning of the importing ontology. Each reference consists of a URI specifying from where the ontology is to be imported. Syntactically, owl:imports is a property with the class owl:Ontology as its domain and range.</p>"
				+	"<p>The owl:imports statements are transitive, that is, if ontology A imports B, and B imports C, then A imports both B and C.</p>"
				+	"<p>Importing an ontology into itself is considered a null action, so if ontology A imports B and B imports A, then they are considered to be equivalent.</p>"
				+	"<p>Note that whether or not an OWL tool must load an imported ontology depends on the purpose of the tool. If the tool is a complete reasoner (including complete consistency checkers) then it must load all of the imported ontologies. Other tools, such as simple editors and incomplete reasoners, may choose to load only some or even none of the imported ontologies.</p>"
				+	"<p>Although owl:imports and namespace declarations may appear redundant, they actually serve different purposes. Namespace declarations simply set up a shorthand for referring to identifiers. They do not implicitly include the meaning of documents located at the URI. On the other hand, owl:imports does not provide any shorthand notation for referring to the identifiers from the imported document. Therefore, it is common to have a corresponding namespace declaration for any ontology that is imported.</p>"
				+	"<p>NOTE: owl:imports is an instance of owl:OntologyProperty.</p>",
					sources_imports, OWL_REF, null) 
			);
					
			name = OWLVocabularyAdapter.OWL + "incompatibleWith";
			URI [] sources_imcompatibleWith = { new URI("http://www.w3.org/TR/owl-ref/#incompatibleWith-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,			
					"<p>An owl:incompatibleWith statement contains a reference to another ontology. This indicates that the containing ontology is a later version of the referenced ontology, but is not backward compatible with it. Essentially, this is for use by ontology authors who want to be explicit that documents cannot upgrade to use the new version without checking whether changes are required.</p>"
					+	"<p>owl:incompatibleWith has no meaning in the model theoretic semantics other than that given by the RDF(S) model theory.</p>"
					+	"<p>owl:incompatibleWith 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_imcompatibleWith, OWL_REF, null) 
			);
			
			
			name = OWLVocabularyAdapter.OWL + "intersectionOf";
			URI [] sources_intersectionOf = { new URI("http://www.w3.org/TR/owl-ref/#intersectionOf-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,			
					"<p>The owl:intersectionOf property links a class to a list of class descriptions. An owl:intersectionOf statement describes a class for which the class extension contains precisely those individuals that are members of the class extension of all class descriptions in the list.</p>"
				+	"<p>An example:</p><br>"			
				+	"&lt;owl:Class&gt;" + NL
				+ 	TAB + "&lt;owl:intersectionOf rdf:parseType=\"Collection\"&gt;" + NL
				+ 	TAB + TAB + "&lt;owl:Class&gt;" + NL
				+ 	TAB + TAB + TAB +"&lt;owl:oneOf rdf:parseType=\"Collection\"&gt;" + NL
				+ 	TAB + TAB + TAB + TAB + "&lt;owl:Thing rdf:about=\"#Tosca\" /&gt;" + NL
				+ 	TAB + TAB + TAB + TAB + "&lt;owl:Thing rdf:about=\"#Salome\" /&gt;" + NL
				+ 	TAB + TAB + TAB +"&lt;/owl:oneOf&gt;" + NL
				+ 	TAB + TAB + "&lt;/owl:Class&gt;" + NL
				+ 	TAB + TAB + "&lt;owl:Class&gt;" + NL
				+ 	TAB + TAB + TAB +"&lt;owl:oneOf rdf:parseType=\"Collection\"&gt;" + NL
				+ 	TAB + TAB + TAB + TAB + "&lt;owl:Thing rdf:about=\"#Turandot\" /&gt;" + NL
				+	TAB + TAB + TAB + TAB + "&lt;owl:Thing rdf:about=\"#Tosca\" /&gt;" + NL
				+ 	TAB + TAB + TAB + "&lt;/owl:oneOf&gt;" + NL
				+ 	TAB + TAB +"&lt;/owl:Class&gt;" + NL
				+ 	TAB +"&lt;/owl:intersectionOf&gt;" + NL
				+	"&lt;/owl:Class&gt;" + NL
				+	"<p>In this example the value of owl:intersectionOf is a list of two class descriptions, namely two enumerations, both describing a class with two individuals. The resulting intersection is a class with one individual, namely Tosca. as this is the only individual that is common to both enumerations.</p>"
				+	"<p>NOTE: This assumes that the three individuals are all different. In fact, this is not by definition true in OWL. Different URI references may refer to the same individuals, because OWL does not have a \"unique names\" assumption. In Sec. 5 one can find OWL language constructs for making constraints about equality and difference of individuals.</p>"
				+	"<p>NOTE: In this example we use enumerations to make clear what the meaning is of this language construct. See the OWL Guide [OWL Guide] for more typical examples.</p>"
				+	"<p>NOTE: OWL Lite is restricted in its use of owl:intersectionOf. This is discussed later in this document, see Sec. 3.2.3</p>"
				+	"<p>owl:intersectionOf can be viewed as being analogous to logical conjunction.</p>",
				sources_intersectionOf, OWL_REF, null) 
			);
			
			name = OWLVocabularyAdapter.OWL + "inverseOf";
			URI [] sources_InverseOf = { new URI("http://www.w3.org/TR/owl-ref/#inverseOf-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,	
				"<p>Properties have a direction, from domain to range. In practice, people often find it useful to define relations in both directions: persons own cars, cars are owned by persons. The owl:inverseOf construct can be used to define such an inverse relation between properties.</p>"
			+	"<p>Syntactically, owl:inverseOf is a built-in OWL property with owl:ObjectProperty as its domain and range. An axiom of the form P1 owl:inverseOf P2 asserts that for every pair (x,y) in the property extension of P1, there is a pair (y,x) in the property extension of P2, and vice versa. Thus, owl:inverseOf is a symmetric property.</p>"
			+	"<p>An example:</p>"
			+	"&lt;owl:ObjectProperty rdf:ID=\"hasChild\"&gt;" + NL
			+ 	TAB + "&lt;owl:inverseOf rdf:resource=\"#hasParent\"/&gt;" + NL
			+ 	"&lt;/owl:ObjectProperty&gt;",
				sources_InverseOf, OWL_REF, null) 
			);

			name = OWLVocabularyAdapter.OWL + "maxCardinality";
			URI [] sources_maxCardinality = { new URI("http://www.w3.org/TR/owl-ref/#maxCardinality-def")  };
			add( new OWLVocabularyExplanation( new URI(name), name,
				"<p>The cardinality constraint owl:maxCardinality is a built-in OWL property that links a restriction class to a data value belonging to the value space of the XML Schema datatype nonNegativeInteger. A restriction containing an owl:maxCardinality constraint describes a class of all individuals that have at most 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>The following example describes a class of individuals that have at most two parents:</p> <br>"
				+	"&lt;owl:Restriction&gt;" + NL
				+	TAB+"&lt;owl:onProperty rdf:resource=\"#hasParent\" /&gt;" + NL
				+ 	TAB+  "&lt;owl:maxCardinality rdf:datatype=\"&amp;xsd;nonNegativeInteger\"&gt;2&lt;/owl:maxCardinality&gt;" + NL
				+	"&lt;/owl:Restriction&gt;",