ODPs and ontological commitments

[Gary Berg-Cross]

I was happy to have a chance to ask Giancarlo at yesterday's Summit session about commitments and ontological design patterns(ODPs).

ODPs, such as "participation", are offered as lightweight, mini theories of reality that stitch together a number of entities. They offer a little bit of insight into background knowledge that you get to by unpacking some concepts.

But, as we said yesterday they are often underspecified and need further ontological analysis to be useful in particular domains as illustrated by Giancarlo's  unpacking of the concept of treatment.

This, of course, does raise the issue in my mind that people using such patterns in different areas need to do more unpacking and specification because there might be a whole family of patterns that are somewhat different depending on situations.

Gary Berg-Cross 

Potomac, MD

240-426-0770

[Alex Shkotin]

Gary,

It was an interesting report and a nice discussion. And as always, it will take some time to study the terminology of the Giancarlo and Nicola approach.

For now, it looks like they are bringing their own terminology into the field of development, construction of scientific and engineering theories. Which should be justified, since there are already many standards and guidelines (aka methodologies).

So, a mini theory is most likely a sub-theory, when we take part of the axioms of a full theory, and sometimes part of the primary terms, and nevertheless obtain some conclusions that will be true in the full theory of the subject area.

background knowledge is the full theory of the subject area that we have at the moment.

unpacking some concepts is most likely a way to define concepts or get more of their properties and connections.

In technological areas (and medicine), we are faced with the fact that theoretical knowledge turns out to be specific to each organization, inventing its own nuances to standard definitions. In this case, general-purpose terms ("participation") will have different definitions in different theories, and the template is just a hint to start with.

The main question is, after all, what theories do we already have in various sciences and technologies? What do they look like? Where are they?

We go to the clinics and, starting from the scheme of their database and the structure of documents, we build an axiomatic theory of their theoretical knowledge and how they use it in practice.

Alex

чт, 30 янв. 2025 г. в 20:03, Gary Berg-Cross <gberg...@gmail.com>:

--
All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAMhe4f0_DBbZ5ae8wRsui%2BvAXYoZyTNnKoTLuKcP97kn_i0Zwg%40mail.gmail.com.

[Giancarlo Guizzardi]

Hi Gary,

Apologies for the delay in replying.

Please see my comments below.

That is an important question.

Let me first point out the confusion around the term ODP (which we addressed here: https://www.researchgate.net/publication/287090355_Ontology_patterns_Clarifying_concepts_and_terminology, many years ago).

People mean many things by the term and some of what are called ODPs are not Patterns at all but idioms (if we want to do justice to the terminology to where DPs came from).

Your question mainly refers to Foundational Patterns.

In my view, a Foundational Ontology can be thought of as a system of theories. Some of these are small micro-theories that can be thought of as Foundational DPs.

A simple example is a particular mereological theory (e.g., extensional mereology). A theory of events (e.g., https://journals.sagepub.com/doi/full/10.3233/AO-190214) is a combination of a number of these patterns (e.g., extensional mereology, participation, etc.)

In a language that commits to a Foundational Ontology (e.g., OntoUML), these micro-theories are manifested as structural patterns in the language. 

In other words, because the grammar of the language is constrained by the underlying foundational ontology, the modeling primitives of that language

are not completely free to occur in grammatically correct expressions of that language and, hence, they agglutinate forming patterns of co-occurring primitives subject to

constraints (induced by said axiomatization). In practice, the language itself becomes a pattern language. To cite one example, in OntoUML, you cannot have free-floating ROLES.

ROLES appear in a relational context and specialize (directly or indirectly) a unique KIND. So, in practice, to model ROLES, one needs to instantiate this pattern.

We discuss this here (https://www.researchgate.net/publication/315442889_From_Reference_Ontologies_to_Ontology_Patterns_and_Back) and more formally here (https://ris.utwente.nl/ws/files/300901463/1_s2.0_S0169023X22000246_main.pdf).

The other way to look at it is that instantiating these patterns in an ontology expressed in that language is a (micro)theory inclusion mechanism, i.e., 

when one uses a parthood relation between events, one is importing the axioms of extensional mereology.

By doing that, one is already approximating the set of possible models of one's domain ontology to the intended models

(i.e., improving precision in Nicola's sense).

Sometimes there are degrees of choices in these instantiations via pattern languages (one could see our take on this, e.g., here: https://link.springer.com/chapter/10.1007/978-3-642-38288-8_5)

But this is the gist.

Now, because foundational patterns are by definition recurring structures that crosscut several domains, it is very often the case that they are under-constrained for representing that fragment of a theory of the domain.

So, they must be extended with domain specific constraints (e.g., the same football player cannot play more than a role in temporally overlapping intervals that are part of the same game).

Most lightweight ontologies are merely descriptive. For example, "Vodafone offers a High-Speed internet service" is a description but it tells me nothing about

the meaning of the sentence, i.e., what is the nature of the entities in the world referred to here. 

In this example, in order to do that, we need to do some ontological analysis of the notion of Service, which we will find out to be terribly polysemic (like almost everything in social/legal domains).

As a result, we will see that Service can mean: 

a) a service offering, which is a bundle of relational modes binding a provider (generally, either natural persons or organizations) and a target market segment (a collective of, possibly, individuals and organizations);

b) a service agreement, which is a bundle of relational modes but of different kinds binding a provider (generally, either natural persons or organizations) and a client (individuals and organizations);

c) a service negotiation, which is a complex event (or a process) in which providers and clients (as above) participate;

d) a service delivery, which is a complex event (or a process) in which providers and clients (as above) participate;

and so on (If you one is interested, this our take on services: https://www.researchgate.net/publication/274700112_A_Commitment-based_Reference_Ontology_for_Services)

By doing this analysis and unpacking those descriptions, one identifies which foundational patterns referring to (relational bundles, events, process) should

be reused and extended. Moreover, as Nicola correctly and insightfully observed in my talk, it also helps to improve the ontology's accuracy (in his sense of the term).

As I observed in Nicola's talk, people think that by letting their ontologies be vague that they are being flexible.

However, what they are doing is to commit to a very flexible conceptualization that can be imprecise, incorrect and inaccurate (again, in Nicola's sense).

The example I used then is a simple predicate Married-with(Person,Person) without any further constraints. This is not a flexible predicate. It is a predicate

that is telling the world that your ontological commitment is to a conceptualization in which you can marry yourself, several people at the same time, some of which are

dead, one of which is yourself, etc. etc. etc...

I hope this clarifies a few aspects of my view on these things.

(sorry for all the paper references but they help to clarify further my view to the people interested)

best,

Giancarlo

[Giancarlo Guizzardi]

--

[Ravi Sharma]

Giancarlo

Thanks for your exciting presentation last week.

What is the current status of OntoUML relationship to OMG?

Also do you have examples of use of micro-theories in the theory as well as in the OntoUML?

Regards.

Thanks.

Ravi

(Dr. Ravi Sharma, Ph.D. USA)

NASA Apollo Achievement Award

Former Scientific Secretary iSRO HQ

Ontolog Board of Trustees

Particle and Space Physics

Senior Enterprise Architect

SAE Fuel Cell Standards Member

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAGG%2B%3DmWzu7tOKMF-AHdRfADcWq_nsMF8SyYMyt8-BfFxd59xww%40mail.gmail.com.

[Ítalo Oliveira]

Dear Ravi,

To quickly answer about the use of micro-theories in theory and OntoUML: all the literature Giancarlo mentioned about modeling patterns apply here. All OntoUML models exhibit these patterns, which are direct consequences of the underlying ontology (UFO). There is a catalog of OntoUML models where you can check some examples. An old OntoUML editor called OLED (now, discontinued) had a feature of instantiating some of these modeling patterns. This is very handy because we can build non-trivial models very easily and consistently by just instantiating those modeling patterns. This feature will eventually be ported to the current Visual Paradigm plugin for OntoUML, which is the modern way of building OntoUML models. The fact that OntoUML is a pattern language in this sense allows other things, such as better modularization algorithms. In summary, what Giancarlo calls "foundational patterns" have several useful practical consequences.

Best regards,

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAAN3-5cdsVq%2BW%3DQ9VxMcJL93_i3CJ7S_pGfhX5u%3Domw47d6DLg%40mail.gmail.com.

--

Ítalo Oliveira

Semantics, Cybersecurity, & Services Group (SCS)

Faculty of Electrical Engineering, Mathematics, and Computer Science

University of Twente

P.O. Box 217, 7500 AE Enschede, The Netherlands

E-mail address: i.j.dasil...@utwente.nl

Office: Zilverling 2034

Personal website 

Blog Not So Short Notes

[Giancarlo Guizzardi]

 Hi Ravi,

(Thanks @Ítalo Oliveira for the reply)

Let me answer your questions from a different angle.

Firstly, let me say that I don't want to deviate the discussion to OntoUML.

I used it as an example but the point I was making was more general.

I use it as an example of both an language that is strongly committed to a TLO (in the sense I mentioned before)

and that is a pattern language. Again, I mean that in a technical sense: its abstract syntax is defined as a

pattern grammar (a graph transformation system that defines these patterns as the actual constructs).

Onde more, we discuss this here (https://www.researchgate.net/publication/315442889_From_Reference_Ontologies_to_Ontology_Patterns_and_Back) 

and more formally here (https://ris.utwente.nl/ws/files/300901463/1_s2.0_S0169023X22000246_main.pdf).

Regarding the relation to the OMG. Currently, there is no relation.

We decided to build the language around UML at the time (20 years ago) to leverage both the tools and the base of users of UML.

Moreover, UML had a language engineering architecture that facilitated things (MOF, metamodeling tools - including verification and model transformation tools, etc.)

However, besides the OntoUML metamodel (technical a profile, i.e., a lightweight extension of the UML metamodel with formal constraints) - this can be seen, for example, here (https://www.sciencedirect.com/science/article/pii/S0169023X21000185),

the grammar is defined also as a pattern grammar (for an important fragment of the language) and its semantics both operationally (via several mappins to, e.g., Alloy, HOL) 

and denotational (to a kind of Intensional Sortal Logics).

Over the years, a few people from the OMG approached us

demonstrating interest in building an official connection.

We tried to do that first via the SMIF (Semantic Model for Information Federation) RFP

but, despite the good people involved there, that initiative didn't materialize in the end.

After that, we never manage to allocate the bandwidth to resume this idea.

In the past two decades, it has been adopted worldwide in academic, governmental and industrial organizations.

In fact, if you are curious, this was exemplified by a talk given by Bruce Baumann in Ontology Summit 2012

(https://ontologforum.com/index.php/OntologySummit2012). If you are curious, please check

2012_02_16 - Thursday: Ontology Summit 2012 session-06 - Track-4: "Large-Scale Domain Applications - I: Energy, Government and Geography" - Co-chairs: Steve Ray & Trish Whetzel - Panelists: - Andrew Crapo, Krzysztof Janowicz, Bruce Bauman, Mills Davis - ConferenceCall_2012_02_16

That all said. Thanks for the interest and, please feel free to contact me about any of this privately

but I really would like to avoid interfering in any way with the focus of this year's discussion - which is extremely important.

best,

Giancarlo

On Mon, Feb 3, 2025 at 9:04 PM Ravi Sharma <drravi...@gmail.com> wrote:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAAN3-5cdsVq%2BW%3DQ9VxMcJL93_i3CJ7S_pGfhX5u%3Domw47d6DLg%40mail.gmail.com.

[Ravi Sharma]

Giancarlo

Thanks for 2012 Summit where I was a sponsor and participant. Reviewed:

 Janowich - " Big (Geo)-Data requires small, local theories (microtheories)"

Bauman - referred OntoUML by you and model reuse

Re -read your thread reply to Gary which addressed microtheories use in ODP and in included pattern language and grammar..

we will take it further 1-1 except if you have further views comments on use of microtheories and limitations across domains in developing theories (and models!).

Congrats for a decade or more of such contributions.

Regards.

Thanks.

Ravi

(Dr. Ravi Sharma, Ph.D. USA)

NASA Apollo Achievement Award

Former Scientific Secretary iSRO HQ

Ontolog Board of Trustees

Particle and Space Physics

Senior Enterprise Architect

SAE Fuel Cell Standards Member

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAGG%2B%3DmX2tA%3Dz6%2BV%3D858T88ZC9Yr83O1XF5gTHJeL6oBVw%2B2%2B_w%40mail.gmail.com.

[Gary Berg-Cross]

Giancarlo,

Thanks for the many clarifications and expansions that you provide in your email.

I do have one very high level question or maybe two.

What is your opinion of the patterns that we see at: http://ontologydesignpatterns.org/wiki/Community:ListPatterns

(from the ODP group and conferences http://ontologydesignpatterns.org/wiki/Main_Page)

And a related question is "what might it take to make such a library  worthy of being used?"

This would make, I think, an interesting paper.  Have you considered it?

Regards,

Gary Berg-Cross 

Potomac, MD

240-426-0770

--

All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAGG%2B%3DmUFGzFSR1c%3DyMwNYX9RvQKtsLK8vkO%3D%3DSH9jkt5x7jkkw%40mail.gmail.com.

[Gary Berg-Cross]

Giancarlo,

I should add another group that promotes ODPs and perhaps does a bit more thinking about foundations for them - Association for Ontology Design & Patterns

Still the question is what the view from OntoUML might be for these.

Gary Berg-Cross 

Potomac, MD

240-426-0770

[Giancarlo Guizzardi]

Gary and all,

I have been following the work of the Semantic Web community on ODPs for years.

There is a lot of interesting serious work there, for sure. In fact, two people in the board of the association you mentioned

are co-authors of the terminology clarification paper I sent before ;-) ( https://www.researchgate.net/publication/287090355_Ontology_patterns_Clarifying_concepts_and_terminology)

Many of the patterns produced in that scope are actually idioms, technically speaking. But that is a terminological issue. As I said, interesting and useful stuff.

Now, to address your question, let me focus on a subclass of those ODPs, namely, foundational patterns. 

How do I see the modeling of Foundational Patterns from an OntoUML perspective?

The stance behind OntoUML is the following: ontology engineering, like any form of engineering, should separate domain modeling from design and implementation.

When doing domain modeling, we should strive to produce models that are correct, precise, accurate (in Nicola's sense) and I would add explanatory.

For that, having a language that is (1) expressive and that is (2) committed to real ontological theories (e.g., of dependence, parthood, instantiation, etc.) is fundamental.

The former (i.e., 1) is important because if the language is too inexpressive then it is extremely hard to satisfy those quality requirements; the latter (i.e., 2) is important because

(as I mentioned in my previous email) it allows one to inherit key foundational axiomatization (the micro-theories I mentioned) that helps immensely with these quality requirements.

Once we get the ontology right from this perspective, we can then map that ontology to several different designs and implementations satisfying different sets of non-functional requirements.

For example, from the same Service ontology (to stick to the example), we can create 5 different OWL implementations of that ontology following different design requirements, but also

create alternative implementations in Prolog, Haskell, Alloy, Isabelle, CASL, Lean, Relational Algebra, whatever...

OntoUML was designed as a language to support this domain modeling phase in ontology engineering. 

We have implemented a number of mappings from the language to a number of languages.  

A language such as OWL does not satisfy either of the criteria (1) and (2) above. 

This is not to disparage OWL. The language was cleverly designed with other constraints in mind, in particular, computational requirements. 

All fine.

So, the view I have w.r.t. to the modeling of Foundational Patterns is the same view I have regarding all ontologies:

they should first be conceived and expressed with the support of language satisfying (1) and (2) above. 

After we get to the right patterns conceptually speaking, then they can be mapped to many different designs and implementations in languages that have been

designed to deal with different types of computational concerns. Basic separation of concerns.

The case of idioms is a bit different but that is a different story.

best,

Giancarlo

[Mike Bennett]

Hi Giancarlo,

That is a great description of the separation of concerns that is vital in any domain of engineering, including ontology engineering and computer applications.

In the Semantic Shed community we have been working towards a crisp explanation of this distinction for some years, and have been looking at a range of techniques for deriving use case specific OWL ontologies, and conventional data models, from an over-arching application-independent ontology (or explanatory ontology).

Some people out there still seem to labor under the illusion that because “ontology” deals with meaning, you only need to do it once – and they then end up in all sorts of a muddle trying to make the same ontology do different jobs, often relaxing the constraints to fit the data until there is little left of the original meanings.

One interesting thing that’s arisen out of the Semantic Shed work is a descriptive framework (articulated by Jim Logan, Max Gillmore and Cory Casanave, with the help of others), in which we talk about the notion of “Direction of Instantiation”.

Picture a model such as a UML Object Oriented design model or an OWL ontology. Put this on the left of your mental screen. To the right is what it is a model of. The model is used to create the data, like the OO analogy of a cookie cutter. It stamps out what the shape of the data should be. The direction of travel is from left to right – from the model to the implementation.

Now picture another kind of model, the explanatory ontology. I’m going to pop this on the left of your mental screen again. On the right I will put the things in the world. Here, the direction of travel is reversed, from real-world things to the model that aims to be a model of those things. The real things precede the model.

This reversal of direction reflects two potential interpretations of the word “instantiate”.

In the first case “Instantiates” means “creates an instance of”. In the second case you are not creating: to be an instance of something in the ontology is to be something that has traits that meet all the conditions in the intension of that model construct. 

These two usages are in opposite directions: One direction is for knowledge (i.e. a theory) of what exists, while the other direction is for recording observations in (a) formation (i.e. “in-formation”). A suitable “formation” for putting that data into is the data schema or, in OWL, what we call a “data ontology”.

An observation in a formation is not the same thing as knowledge.

We can now line these up and see a flow from the real world things to the explanatory ontology, then we can apply some transformation from the explanatory ontology to some simplifying, data-focused ontology, and from that to some implementation.

The transformation may be as simple as identifying appropriate datatypes for data that represent real world things and relationships. It may add data surrogates for real-world truth-makers (for example, many legal capacities and capabilities may have a data surrogate in the form of a government license).

An enterprise-wide knowledge graph may also chop off some of the higher-level abstractions or collapse them into fewer levels of subsumption. Since the Explanatory Ontology has already dealt with those concerns, there is no need to replicate them in the knowledge graph. For narrower, use case-specific applications, you might collapse and compress parts of the explanatory ontology, for example replacing complex patterns and constructions (such as Relators and Roles in UFO) with ontology design patterns of simple object properties for the context of that use case.

There’s a whole lot more to that, and we’ve done some studies.

But I think there is also a third kind of thing in play.

When I look at various LinkedIn posts on knowledge graphs and linked data, with some exceptions the focus seems to be on understanding what classes of thing and relationships exist in the data, rather than necessarily the meanings of the things. Modelers are thinking about the shape of the data – indeed, the data shapes standard SHACL was introduced to enable modelers to say more at this data level.

The presence (and cardinalities, restrictions etc.) of relationships between things in the available data may well be coextensive with an account of the meanings of those things, most of the time. But even when these are coextensive, they are not the same thing.

Truth is not meaning.

The simplest difference is that a data ontology need not stand up all the properties that make up the necessary and sufficient conditions for class membership. They need not even stand up data surrogates for those things. They need only stand up the data that the application cares about, and that exists in the data domain. So the relationships in the linked data need not represent the meanings of things, even if they reflect it in part.

Also, and for good reasons, an explanatory ontology teases things apart whereas a data ontology conflates them back together again. It also need not have the higher levels of logic needed to capture some aspects of the definitions of things in reality.

But the requirements for representing the classes and relationships in the data may go beyond these differences, in interesting ways.

Some exceptions will make this clearer.

When I was doing an ontology for loans, I was asked not to include loans that were unsecured. It may be that you don’t want or don’t expect the data to handle unsecured loans, but it is part of the definition of a loan that it either is or is not secured. That’s part of its meaning.

Similarly, it may be tempting in an ontology to constrain the allowable range of the property “owns” such as to exclude “Person” from the range of things that can be owned. After all, you can’t own people.

However, that is a deontic limitation not a semantic one. It is legally forbidden, and morally reprehensible, to own people. However, you can’t define the term “slave” without that relationship.

Meaning is not truth.

This is not a criticism of the data ontology. In fact, it is a good thing. Being able to add a layer of deontic limitations to what can be expressed would be a very good thing to add to the data ontology, for many use cases.

Not all use cases will require the same additional deontic features, for example some compliance use cases will need to dig deeper into the meanings of things, in order to detect or prevent those things.

This is another good reason for this engineering separation of concerns. Because we have decoupled the data ontologies from the explanatory ontology, those data ontologies may not only remove assertions that have nothing to do with the data or the current application, but may add restrictions or other information to reflect what’s expected in the data, or as a means of detecting when something in the data is illegal or impermissible. You can use this new freedom to represent what Ronald Ross defines as “business rules”, for example "Nobody should be swimming in this pool at this time". Or to use data-oriented logic standards like SWRL or RIF to implement logical data rules, which are not the same thing. And of course you can layer on SHACL shapes here. 

By decoupling the data ontology from the business-facing explanatory ontology, you can not only have less of the original semantics in that model but you can do more with the shapes of the data itself.

It seems to me that a lot of folks in the data ontology world resist this kind of separation of concerns because they perceive that it will be more work to create two or more different ontologies. But in fact, having this separation of concerns reduces not only the workload but also the complexity of the ontologies used in individual applications. In the case of these deontic edge cases, it also frees up the application ontologies to do things that the concept ontology was never intended for.

Mike

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAGG%2B%3DmVS5VQSuEewK9xgqkSj9ir2S%2B1bp%3DakKj4XjyrTfnSzdQ%40mail.gmail.com.

[Jim Logan]

Mike,

I like what you did with the material I contributed. Well done.

-Jim

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/d5778169-0f82-4c91-8022-342cffb8c5d6%40hypercube.co.uk.

[Nadin, Mihai]

Mike Bennett: respect! 

Mihai Nadin

Sent from planet earth

On Feb 18, 2025, at 9:58 AM, Jim Logan <jll...@gmail.com> wrote:

 Mike,

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/D8E86C56-9826-4440-AF4C-62D375DDE162%40gmail.com.

[John F Sowa]

I agree that Mike's note has a great deal of important observations.  I just want to emphasize the following paragraph:

Mike B:  Some people out there still seem to labor under the illusion that because “ontology” deals with meaning, you only need to do it once – and they then end up in all sorts of a muddle trying to make the same ontology do different jobs, often relaxing the constraints to fit the data until there is little left of the original meanings.

This is the point of Doug Lenat's distinction between a very underspecified top level and an open-ended collection of lower-level branches or modules for every kind of application.  To avoid defining the same word in different ways, he insisted on using hyphenated phrases to name the lower levels so that different branches would have distinct symbols.

For further evidence, just look at any dictionary (or check any online dictionary), every word has multiple definitions, and different dictionaries almost always have different selections of subdefinitions.  None of them are wrong.  All those differences (and many, many more) are being used by speakers of the language every day.

John

 

---

From: "Nadin, Mihai" <na...@utdallas.edu>

[Gary Berg-Cross]

Mike,

Just a quick, intuitive comment that I would add a process of analysis and conceptualization to both your left-right diagrams. (it also reminds me of the triangle of meaning if we connect 3 of these ideas and let the UML and explanatory model both be ideational or a combination of ideation and language expression of the ideas,

To get from the cookie cutter UML Object Oriented design model or an OWL ontology. on the left and  data we need some conceptualization along that arrow. (Example, is this piece of location data a "site object" in my model.  Or, does "diagnosis" in my UML model/map to part of the assessment data?

UML(rep) -> Data

        mapping?

Explanatory ontology (semantics) <- Real world (truthmaker)

                         conceptualization I define marriage this way....

Gary Berg-Cross 

Potomac, MD

240-426-0770

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/d5778169-0f82-4c91-8022-342cffb8c5d6%40hypercube.co.uk.

[Gary Berg-Cross]

BTW,

We are scheduling Kit Fine for a talk in March so we may get some more thoughts on truthmaking.

Gary Berg-Cross 

Potomac, MD

240-426-0770