**Modal Logic**

Luc got himself kicked out of day care yesterday. He was running a temperature, coughing etc. So I had to babysit while working today... slowing things down quite a bit. That means more work on the weekend, unfortunately. I hate to think what my sore throat tonight means!

Fortunately, my sister was able to watch Luc while I went in for the Logic group that's held on Wednesdays. Today we covered Modal Logic. I found it all interesting, right up to the point where we looked at the group of Kripke logics.

These logics are based on 5 axioms, labeled T, D, 4, B and 5. Each of these axioms describe specific types of relationships: Reflexive, serial, transitive, symmetric, and Euclidean. It was this last one that got my attention.

OWL has no mechanism for describing how relationships relate to one another (other than with inheritance). Consequently, it is impossible to describe an "uncle" relationship as being built from a "parent" and a "brother" relationship. This is often devolved to a rule language to perform. However, it is a valid and useful thing to describe in an ontology.

Euclidean relationships go some way to addressing this. They allow a description between entities *A*, *B* and *C*. If *A* relates to *B* and *C* in the same way, then *B* relates to *C* in some other way. That doesn't work for the "uncle" relationship, but it would work for describing siblings if they share a common parent.

I wonder if there is some way to incorporate this effectively into OWL?**Linking Blank Nodes**

I finally worked out the best way to traverse these nodes.

The rules all need to sit in memory (even though the corpus of RDF data does not), so it is appropriate to build up the data in memory. I was concerned about the difficulty of this, particularly when it involved new queries for every branch on the tree, but I now realise that this is not needed. Instead, I have been able to get most of the information in a raw form with a simple query, and put it into `HashMaps`

. Then I can walk my way through the data quite easily.

More importantly, this has the added advantage that almost all of the data comes from a single query. This means that there are no concerns about blank nodes comparing incorrectly, regardless of transactions. However, I've tried them from one query to the next, and all seems well. This was important, as I really needed to split the queries up into at least two anyway. My only other option was to union the results of two vastly different queries together, using the same variable names, along with predicates which are given variable names but set using <tucana:is>. Yuck.

That reminds me. No one commented on me wanting to change all the *tucana* references to *kowari*. That must mean that no one minds, huh? :-) Perhaps I should change the code to accept either for the time being, before finally dropping the *tucana* support.

## Wednesday, June 01, 2005

Subscribe to:
Post Comments (Atom)

## 2 comments:

Hello,

Interesting thoughts ! You seem to take interest in logic from a computational background. I am built the other way around. So here is a little corrigendum of your euclidity definition. If I can express it in LISP-like syntax :

(IMPLIES (AND (R a b) (R b c)) (R b c))

Stated that way, euclidity relates facts or things with ONE relation.

"Belonging to the same family" could be euclidean.

The euclidean relation is a way to express the euclidean space in modal logic, just like the axiom 4 could express topology.

Best of luck with your researches,

Benoit St-Pierre

University du Québec à Montréal

The relation is :

(IMPLIES (AND (R a b) (R a c)) (R b c))

Sorry for the typo.

Ben

Post a Comment