OntologySummit2007: Frameworks For Consideration (T1Y)
Dimensions-Aspects (T1Z)
First proposed by: LeoObrst in his 2007.01.28 posted to the [ontology-summit] list - http://ontolog.cim3.net/forum/ontology-summit/2007-01/msg00083.html (T20)
Following article being organized by: CharlesTurnitsa (T21)
Formality (U1Q)
Scale (U4V)
Informal (Formality = 0) vs. Formal (Formality = 1) (U1R)
Description (U1S)
Comments (U1T)
- I don't quite get what this means. If we're not talking about artifacts that are somehow used to influence software to do things we want, I don't see the point. So, for some thing O, if Formal(O) means that O is a logical theory, then, following ChrisM, I don't see what anything not formal should even be considered, since otherwise, it would be pretty close to impossible to say how it could be used for some computational end. [Bill Andersen andersen@ontologyworks.com] (U1U)
- The ecumenical definition of "ontology" that Mike Uschold and I have used is: (U1V)
- "An ontology includes a vocabulary of terms together with a specification of the intended meaning of the terms." (U1W)
- Different approaches to ontologies are distinguished by the latter condition, that is, in the way that they specify the intended meanings. (U1X)
- Leo is pointing to a basic partitioning of these approaches. (U1Y)
- A formal ontology is a set of sentences in a language that has a model theory, that is, a notion of interpretation that supports truth assignments, satisfiability, and entailment. (U1Z)
- As observed by recent discussions, this is a necessary but not sufficient condition, since there are sets of sentences that not everyone would consider to be an ontology, but this is not my point here. (U20)
- On the other hand, the specification of intended meanings in an informal ontology relies on extralogical mechanisms (natural language, diagrams, canonical software implementations). (U21)
- The line does become a little blurry when the expressiveness of the underlying logical language for an ontology is insufficient to axiomatize the intended interpretations of the terms. For example, in OWL-S (the OWL ontology for web services), different classes of processes such as Unordered,Sequence,etc are axiomatized in OWL. Nevertheless, OWL is not expressive enough to capture the full intended interpretations of these classes, which is specified in natural language as documentation. [Michael Gruninger gruninger@mie.utoronto.ca] (U22)
Expressivity (U23)
Scale (U24)
Description (U25)
Expressivity of the semantic model (i.e., underlying knowledge representation language or logic) (U26)
Comments (U27)
- This is a property of a logical system, independent of the instances of which we wish to regard as "ontology", so I'd exclude this dimension. [Bill Andersen (andersen@ontologyworks.com] (U28)
- It is a property of a class of structures AND the logical language. There are classes of structures that are not first-order definable, and classes of structures that are not definable in DL. This is an important issue because we need to be able to determine whether the intended interpretations of the terms in the ontology can be defined within the advertised formal language. [Michael Gruninger gruninger@mie.utoronto.ca] (U29)
- There are two very important, but widely misunderstood points about logic: (U2A)
- Expressivity of a statement or a theory is independent of the language in which it is stated. Translation *never===changes the expressivity. (U2B)
- Computational complexity is *not===a result of the expressivity of any statement, but of the algorithms used to process that statement. (U2C)
- For example, SQL allows full FOL for queries and constraints, but the algorithms that process SQL databases are always decidable and never take more than polynomial time. In fact, many if not most SQL queries can be evaluated in linear or even logarithmic time. (U2D)
- An example of a logarithmic-time query: (U2E)
- "Find John Doe's department, manager, and job code." (U2F)
- An example of a linear-time query: (U2G)
- "Find all employees who earn more than their managers." (U2H)
- Even highly complex queries can be evaluated very efficiently if they are only processed on a subset of the database: (U2I)
- "For all employees in department C99, find [Very Complex Query]." (U2J)
- This query may require a polynomial with a large exponent, such as 3. (U2K)
- But if there are only 20 employees in dept. C99, the time would be proportional to 8,000 -- a trivial number with current hardware. [John Sowa sowa@bestweb.net] (U2L)
- John, (U2M)
- What I did mention in my note 2 is that there is a field called "descriptive (expressive) complexity" that has emerged in recent years that in fact tries to correlate these, i.e., note and gauge the close correlation between expressing and checking. This goes back to at least Immerman, in the early 80s, e.g., []. (U2N)
- Thanks, (U2O)
- Leo [lobrst@mitre.org] (U2P)
- Leo, (U2Q)
- Descriptive complexity is addressing a different topic, which involves finding a description (i.e., a statement) that expresses a given property S. As Immerman says, (U2R)
- ... a more natural question might be, what is the complexity (U2S)
- of expressing the property (U2T)
- That question might be "more natural" for the problem that Immerman is addressing: How does one express a given property? (U2U)
- But if we are given an ontology, we already have the statements, and the relevant question is how much time it takes to process those statements for various purposes. That is the old-fashioned version of computational complexity, not descriptive complexity. (U2V)
- In any case, it doesn't matter which version of complexity is being considered. The points I made are equally applicable to both: (U2W)
- Expressivity of a statement or a theory is independent of the language in which it is stated. Translation from one language to another can never change the expressivity. (U2X)
- Computational complexity is not determined by a statement, but by the algorithms that process the statement. (U2Y)
- We have to wean people away from the knee-jerk reaction that complexity is determined by the language. They have to learn that complexity is determined by what you do with a statement, not by the statement itself and certainly not by the language used to state it. (U2Z)
- Fundamental principle: Limiting the expressive power of a language can never reduce the time required to solve any problem. It merely restricts the kinds of problems that can be stated. (U30)
- John (U31)
- John, (U32)
- I think the issue is that they are very correlated: checking (computation) and the expressing (language). Of course one can do arbitrarily more complex computations with any given item, i.e., generate the infinite number line given an initial number, or all possible prime numbers, etc. That has more to do with the use cases we employ the ontologies for (though of course they also correlate with the expressiveness). (U33)
- Leo (U34)
- Re: We have to wean people away from the knee-jerk reaction that complexity is determined by the language. They have to learn that complexity is determined by what you do with a statement, not by the statement itself and certainly not by the language used to state it. (U35)
- This is then a different view of complexity than one would typically consider in, for example, an architectural language (that may also be an ontology) or an execution language. For this domain user complexity (of usage) is very related to the number of statements it takes to express a concept. A language that can express a concept in one statement is less complex to use than one that expresses the same concept in 10 statements. However the first may be a more complex language since it has more concepts. What the first language is providing is a first-class representation of a concept that is likely to be a pattern in the second language. In formal terms they are equally expressive but in user terms one is more complex and less expressive. (U36)
- I would also argue that since the language requiring the pattern has not encoded knowledge of the pattern it has lost important information as to the intent of the more compact statement (and reversing the pattern may not be possible). So while formal semantics may be preserved user intent is lost. This user intent is part of the ontology of the users domain. (U37)
- Perhaps we could find a way to capture both these formal and user-centric dimensions? [Cory Casanave cory-c@enterprisecomponent.com] (U38)
- No, sorry, Cory, I beg to differ: that is absolutely not the knee-jerk reaction. (U39)
- Rather, there are computational complexity classes based on problems you want to solve, in terms of space and time, which are in fact the normal definition of complexity in computer science. Language complexity has until recently had little to do with that notion. Now it does. (U3A)
- Descriptive complexity is new. (U3B)
- We are not talking yet about user complexity. Yes, I would say a million statements are much more complex for a user than 1 statement which generalizes those. A schema or ontology or theory or grammar describes potentially an infinite number of items. The pattern (those are all patterns), just like a scientific theory, covers items you have not yet seen or potentially imagined (because you don't yet know the full ramifications of the pattern/theory). (U3C)
- When we get into user intent, we have to extend our usual formal semantics to include formal pragmatics issues (that is the definition of formal pragmatics, i.e., semantics in context according to use and intent). (U3D)
- Thanks, (U3E)
- Leo (U3F)
Concept-based (U3G)
Scale (U3H)
Term (Concept-based = 0) vs. concept (real world referent)(Concept-based = 1) (U3I)
Description (U3J)
Comments (U3K)
- I assume that the salient opposition here is whether an ontology is (U3L)
- Concept-based (the terms in the ontology refer to concepts = ideas in the minds of experts, meanings, units of knowledge [defenders of concept-based ontologies should specify which] (U3M)
- Reality-based (the terms in the ontology are intended to refer to universals (types, kinds), to collections (sets, classes) of instances, or to some combination of these two (Barry Smith phismith@buffalo.edu) (U3N)
- Barry touched on this. I really do not understand what "concept- based" means. If you have an ontology and want to go so far as to include concepts in its scope, then good. Else, it seems a wiggle word, left to whatever extra-logical powers one would like to ascribe to "concepts". [Bill Andersen andersen@ontologyworks.com] (U3O)
Mathematical Ordering (U3P)
Scale (U3Q)
Description (U3R)
Mathematical ordering, structure, definition of the privileged parent-child relation (U3S)
Comments (U3T)
- I assume that the privileged parent-child relation should be the is-a (is a subtype / is a subconcept of) relation; I do not know what is meant by 'mathematical ordering' [Barry Smith] (U3U)
Application Focus (U3V)
Scale (U3W)
Description (U3X)
Use cases, etc. (part of this is precision of the service needed, e.g., metadata/topic terms for a document to aid in broad doc topic retrieval vs. a semantic service query, specfication, or composition) (U3Y)
Comments (U3Z)
- Proposed scale: does an ontology have a plurality of independent users [Barry Smith] (U40)
- This depends on a clear exposition of the intended functions of ontologies. [Bill Andersen andersen@ontologyworks.com] (U41)
Granularity (U42)
Scale (U43)
Description (U44)
Precision, Scope (U45)
Comment (U46)
- I think granularity, precision and scope are three different things [Barry Smith] (U47)
Development Philosophy (U48)
Scale (U49)
Empirical (bottom-up) [0] vs. Rationalist (top-down) development [1] (U4A)
Description (U4B)
Methodology (i.e., arbitrary folks add or annotate terms/concepts vs. a rigorous ontology development) [No scale determined yet; Some combination? Middle-out? But what does that mean?] (U4C)
Comments (U4D)
Human Coded (U4E)
Scale (U4F)
Human-coded [1] vs. machine-learned/generated [0] (U4G)
Description (U4H)
Comments (U4I)
- Human coded also means: validated by experts [Barry Smith] (U4J)
Automated Reasoning (U4K)
Scale (U4L)
Description (U4M)
And complexity of that, i.e., one could have transitive closure or subsumption down a subclass graph vs. theorem-proving (U4N)
Comments (U4O)
Prescriptive vs. Descriptive (U4P)
Scale (U4Q)
Descriptive [0] vs. Prescriptive [1] (U4R)
Description (U4S)
A commonsense or conceptually-profligate ontology vs. an ontology that specifies that this is the way the world is) (U4T)