00:40:08 <sbp> sbp has quit
00:47:03 <Shalrath> Shalrath has quit
00:52:31 <mnot> mnot has joined #rdfig
00:53:35 <Shalrath> Shalrath has joined #rdfig
02:21:50 <Skyline> Skyline has joined #rdfig
03:06:21 <em_> em_ has quit
04:17:17 <Skyline> Skyline has quit
05:36:46 <mnot> mnot has quit
06:47:53 <Shalrath> Shalrath has quit
06:53:57 <dmiles> dmiles has quit
06:54:17 <kifbot> kifbot has quit
07:33:56 <antiClauz> antiClauz has joined #rdfig
07:34:51 <antiClauz> antiClauz is now known as dmiles
07:43:40 <jonas> jonas has joined #rdfig
07:45:21 <jonas> jonas is now known as jonas6789012345678901234567890
07:45:47 <jonas6789012345678901234567890> jonas6789012345678901234567890 is now known as jonas
08:13:09 <Skyline> Skyline has joined #rdfig
10:31:16 <Skyline> Skyline has quit
10:31:26 <jonas> jonas has quit
13:55:04 <em> em has joined #rdfig
14:26:00 <AaronSw-UK> AaronSw-UK has joined #rdfig
14:26:03 <AaronSw-UK> hi everyone
14:57:33 <AaronSw-UK> AaronSw-UK has quit
15:08:54 <sandro> sandro has joined #rdfig
15:49:38 <em> em has quit
15:56:01 <em> em has joined #rdfig
16:36:32 <sbp> sbp has joined #rdfig
16:40:36 <wkearney99> wkearney99 has joined #rdfig
16:47:29 <em> em has quit
17:02:50 <jhendler> jhendler has joined #rdfig
17:08:18 <wkearney99> wkearney99 has left #rdfig
17:19:47 <jhendler> jhendler has left #rdfig
17:22:55 <bijan> bijan has quit
17:24:55 <bijan> bijan has joined #rdfig
17:25:53 <sbp> sbp has quit
19:11:06 <sandro> hey all
19:16:38 <jhendler> jhendler has joined #rdfig
19:17:32 <bijan> Hey sandro.
19:18:23 <sandro> it's so quiet.  :)
19:19:18 <jhendler> Seems that DanC and AaronSw are both on vacation...
19:22:47 <sandro> That might do it.  :)
19:24:45 <dmiles> dmiles has quit
19:29:12 <mnot> mnot has joined #rdfig
19:44:36 <ambient> ambient has joined #rdfig
20:26:37 <Skyline> Skyline has joined #rdfig
20:28:33 <ambient> ambient has quit
20:46:33 <sandro> Isn't the rdf model broken in only allowing 0-1 labels on a node?    Those labels are simply unambiguous names for the object denoted by the node, so if two nodes denote the same object it should be possible to merge the nodes -- except because only one label is allowed, you can't.    Isn't that wrong?
20:47:53 <bijan> "Wrong" in what way? Just because two nodes denote the same object doesn't mean you can merge assertions about them.
20:48:18 <bijan> *Especially* in intensional contexts, which documents themselves tend to be :)
20:49:39 <sandro> What's an "intensional context" ?
20:51:27 <bijan> well, all the propositional attitudes form intensional contexts.
20:51:55 <bijan> Just because I believe John is smart, and it's true that John is Bob, doesn't mean I believe Bob is smart.
20:52:31 <bijan> Merge John and Bob and you end up with real problems.
20:52:56 <sandro> because Bijan may not know that John is Bob?
20:53:13 <bijan> Even if I do, I might not have made the connection.
20:53:23 <bijan> But yes, I might not know that John is Bob.
20:53:55 <sandro> hrm.
20:54:08 <bijan> (I.e., if we're asking about my explicit beliefs, even my believe that John is Bob might not have ever played a roll in my judgements about John.)
20:54:34 <bijan> (In a standard Hintikka type epistemic logic, however, my knowing/believing the John is Bob should do the right thing.)
20:54:58 <sandro> silly philosophers.   :-)
20:55:44 <bijan> Hmm. Intensionality is very hard to elide, much less get rid of :)
20:55:56 <bijan> Take a document that says, "John is smart".
20:55:59 <zippy> zippy has joined #rdfig
20:56:11 <bijan> That John is Bob isn't enough to make that document have said that Bob is smart.
20:56:22 <Skyline> Skyline has quit
20:56:24 <bijan> This become more critical in, say, legal documents.
20:56:51 <bijan> Where under what name you receive something might make a difference.
20:57:37 <sandro> Yeah, but that's a difficult way to organize your data structures.
20:57:58 <sandro> difficult-to-work-with.
20:58:12 <bijan> Hmm?
20:58:30 <bijan> It's not a matter of difficult to work with, it's a matter of the logic of the situation.
20:59:04 <bijan> Yes, it's more difficult...but,uh...you're stuck with it! :)
20:59:39 <sandro> if you an get to a state where you don't care what names different sources used for things, (as we generally do immediately, subconsciously) situations and reasoning are much simpler.
21:00:01 <bijan> (as we generally do immediately, subconsciously) that's false.
21:00:11 <bijan> And of course fully extentional contexts are simpler.
21:00:43 <sandro> I don't understand intensional vs extentional, as hard as I try.....
21:00:49 <zippy> If rdf needs to support various logical systems (does it)?
21:00:49 <jhendler> hmm, but doesn't this point out a contradiction - whole reason for reification is that I'm supposed to believe everything, but I cannot merge because of contexts -- seems to me a belief in contexts of various types would make reification go away (oops = that's an old argument, sorry...)
21:01:33 <bijan> Well, there's two sorts.
21:01:38 <sandro> Why do you say that's false?   There are lots of riddles and such which only work because people do it, I think.
21:01:42 <zippy> then multiple labels should be allowed for those who wish to merge items, otherwise how do you know that they refer to the same thing?
21:02:00 <bijan> zippy, you have an explicit statement to that effect.
21:02:15 <zippy> ?
21:02:24 <jhendler> sandro - intentional (with t and s) and extensional (with t and s) have been around logic forever -- some of us think they have little practical purpose, others claim logic is meaningless w/o them...
21:02:30 <bijan> sandro, I say so because it *is* so. :)
21:02:56 <jhendler> I find ignoring the difference has never got me in much trouble in the real world, so I intend to do the same in RDF...
21:03:02 <bijan> Don't confuse our ability to straighten things out (i.e., merge nodes) for our merging nodes a certain way.
21:03:14 <Skyline> Skyline has joined #rdfig
21:03:19 <bijan> <sigh/>You can't ignore them, per se. We deal with them all the time.
21:03:23 <sandro> Does the spelling with t or s mean anything?
21:03:29 <bijan> Yes.
21:03:47 <jhendler> yes, but no one remembers which is which most of the time :->
21:04:27 <sandro> Thanks, Jim.  :-)
21:04:32 <jhendler> sandro - can labels be filled with anonymoys nodes?  IF so, one could have the label itself be a graph that includes nodes with one label each - would be a nice way to do it.
21:04:35 <bijan> intentional has to do *intentions*. I.e., I intentially hit the ball.
21:04:49 <bijan> I.e., I deliberately did so.
21:05:23 <sandro> Intent.
21:05:29 <bijan> Intensional with an s has to do with the ability to substitute equals for equals while retaining truth.
21:06:03 <bijan> Two properties are extentionally equivalent when they have all the same members.
21:06:17 <bijan> They are intensionally equivalent when they ahve the same meaning.
21:06:53 <bijan> "Creature with a heart" and "creature with a kidney" are (in the acutal world) extensionally equivalent but intensionally distinct.
21:07:03 <jhendler> bravo bijan - that's the best summary I've seen yet.
21:07:40 <sandro> jhendler, I don't quite follow.  I imagine the labelling is really just adding another arc-to-a-literal.   ( http://www.w3.org/2001/12/uname/ )
21:07:41 <bijan> :)
21:08:54 <sandro> Where does the S spelling come from?   It sounds like it's still about Intent.
21:09:02 <jhendler> sandro - I was toying with something like
21:09:21 <jhendler> :foo a <whatever>;
21:09:59 <jhendler>  label [ member X ; member Y];
21:10:19 <jhendler> :X a <whatever>; label "LABEL1".
21:10:19 <bijan> [Latin intnsi, intnsin-, from intnsus, stretched. See intense.]
21:10:19 <bijan> --------------------------------------------------------------------------------
21:10:19 <bijan> in7tension7al adj. 
21:10:37 <jhendler> :Y a <whatever>; label "LABEL2".
21:10:53 <sandro> Where is the tension in the hear/kidney example?
21:11:09 <sandro> vs the "slack" with extension ?
21:11:19 <bijan> There isn't. You're being too literal.
21:11:27 <jhendler> looks a lot uglier now that I type it out, but graph doesn't look too bad - basically, it is inventing a "merged-label" class and giving it multiple members each of which has one label.  I'm just not sure if it is legal...
21:11:34 <bijan> That's just an etymology :)
21:12:01 <sandro> I find etymology often helps a lot.
21:12:11 <bijan> If I had to make up a faux etymology, I'd say that intensions can be "stretched" to cover a lot of extensions.
21:12:19 <bijan> yes, but if you over do it, it doesn't help :)
21:13:38 <bijan> Hmm. There's also "intentonality" like "aboutness"
21:13:41 <jhendler> bijan gave an intentional (with a t) example of false etymology
21:13:51 <bijan> So really three senses.
21:14:09 <bijan> And teh "with a t" and "with an s" is usually to distinguihs aboutness and meaning.
21:14:15 <bijan> Or reference and sense as one might call them.
21:14:54 <jhendler> I don't think extension with a "s" actually exists, although I vaguely recall a Searle paper from the 70s or early 80s where he played with the concept.
21:15:04 <jhendler> (again, I may have the letters wrong :->)
21:15:19 <bijan> I don't know of an extension with an s, off hand.
21:15:54 <sandro> there is extensible.
21:16:20 <zippy> who first introduced the distinctions - reference, and sense?
21:16:21 <bijan> Ah, yes. Of course.
21:16:28 <jhendler> I think he was fooling around with the idea of things that were both extentionally and instensionally equivalent beings called "extensional" -- was part of some complex logical stuff about implicature in conversation...
21:16:30 <bijan> Frege, at least in that way.
21:16:50 <bijan> The Paper in question being "On sense and reference".
21:17:03 <bijan> Using the famous morning star/hesperous examples.
21:18:28 <jhendler> sandro - you may recall "morning star/evening star" examples from early DAML discussions w/Tim and Dan, Lynn S. was teaching some Fregian (Fregean?) concepts - this paper is generally considered a seminal paper.
21:18:37 <bijan> Fregean
21:18:44 <bijan> *THE* seminal paper.
21:19:52 <sandro> Are the evening star and the morning star both the same star?
21:19:56 <bijan> Yes.
21:20:01 <bijan> Actually, they're venus :)
21:20:03 <jhendler> I, on the other hand, was holding out that on the web, using URIs, the problem is reversed - it is easy to tell when things are necessarily the same (when http://.../evening.star and http://.../morning.star resolve to same place on web) but much harder to tell when they are intentionally different (mailto:hendler@cs.umd.edu and http://.../hendler)
21:20:04 <bijan> So not a star at all :)
21:20:07 <jhendler> venus.
21:21:27 <jhendler> in regular logic - variables proliferate and binding to constants is hard.  On the web, constants proliferate and variables are hard to express.  Pat Hayes and I discussed this at length in some email once, but I don't think it was archived... I think it was when I was convincing him that web logics might actually be "interesting" as well as important
21:21:48 <bijan> jhendler, yes, that's one of the interesting things.
21:22:01 <jhendler> I get to give a talk at this year's KR conference, have to try to get some of this stuff down better.
21:22:03 <bijan> I.e., the reversal of variables and constants.
21:22:14 <bijan> Actually, in regular logic constants are easy too.
21:22:20 <jhendler> bijan - what are some others you would include 
21:22:46 <bijan> It's just they aren't very interesting because you aren't looking at their meaning at all.
21:22:50 <sandro> Interesting.   Does "regular logic" have any place for literals, or are those just constants?
21:23:02 <sandro> (except they are constants you know to be unequal)
21:23:12 <jhendler> bijan - yes, they are "easy", but usually the assumption is a small base of  (never mind, you just said it better - not looking at the meaning, and don't effect the models)
21:23:31 <bijan> "Literal" in the conventional sense are syntactic feature of surface grammar. I think.
21:23:48 <bijan> I'd tend to say that Literals are subkind of constants.
21:24:28 <bijan> The thing is, of course, is that we tend to peek "inside" URIs.
21:24:32 <jhendler> I agree w/bijan, don't know what a "literal" would be.  Two distinctly named constants are unequal by definition in most logics.  (i.e. X != Y; ?X may or may not equal ?Y)
21:25:00 <bijan> Both the surface syntax of the string, and the objects denoted.
21:25:08 <jhendler> (note, except in these extentional/intensional contexts we've been discussing)
21:25:24 <bijan> Indeed, it's hard not to, given existing web practices.
21:27:12 <sandro> I have been under the impression that assuming X != Y is the unique names assumption, which while present in Prolog, is not present in FOL and is being assumed to be not present in RDF-related logics.
21:27:55 <bijan> I don't think jim meant that they were *unequal*, but merely that they *may be* unequal. I hope ;)
21:28:00 <bijan> no.
21:28:07 <bijan> Maybe.
21:28:09 <bijan> It depends.
21:28:29 <bijan> Actually, if you had unique names then the semantics of EI would be a *lot* easier.
21:28:30 <sandro> I think he mean ARE unequal, and that variables MAY be equal/unequal.
21:28:39 <jhendler> hmm, many logics make a unique name assumption w/respect to intensionality.  
21:28:55 <sandro> No question UNA makes things easier -- you just can't implement it in a distributed manner.
21:29:19 <bijan> I don't think FOL has a UNA for constants.
21:29:34 <sandro> I don't either.
21:29:41 <jhendler> Part of Freges whole thing had to do with what you're calling unique names -- but remember, literals and logical constants are different.  
21:29:52 <bijan> I don't see that a = b is ill formed.
21:30:14 <sandro> I think literals are effectively objects with a UNA.
21:30:24 <bijan> Really?
21:30:27 <bijan> Why?
21:30:39 <sandro> Because "Bijan" = "Sandro" is ill-formed.
21:30:48 <jhendler> let me think a bit about FOL and UNA -- I think FOL does indeed have a UNA with respect to the actual constants - not to "designations" of the constants.  i.e. A big difference between "Sam Hendler" and father-of("Jim Hendler")
21:30:57 <sandro> Nah, just false.
21:31:02 <bijan> I was wondering :)
21:31:27 <bijan> jim, yes, I was wondering if we were straying all over the syntax/semantics line.
21:31:45 <jhendler> bijan - seems to me literals are actually more like function symbols in many logics, which actually is an interesting idea -- supposing WOL creates a "designates" term -- so we could say
21:32:06 <jhendler> "mailto:hendler@cs.umd.edu" wol:designates "Jim Hendler.
21:32:24 <sandro> It's how you do graph matching in RDF -- you look for the literals and the properties which you know to be UniqueProperties and UnambiguousProperties.     (and the "URI"'s, if you not -as I suggest- treating them as just another UnambiguousProperty.)
21:32:29 <jhendler> "http://www.cs.umd.edu/~hendler" wol:designates "Jim Hendler"
21:33:22 <sandro> You can't do much with function symbols -- like talk about their equality -- in FOL, can you>?
21:33:43 <jhendler> but wait - we have now gone way over the syntax/semantics line 
21:33:57 <sandro> true,
21:34:11 <jhendler> sandro - sure you can talk about their equality, etc in FOL -- perfectly legal to say
21:34:20 <bijan> Hmm. Y'know, it might be fun to have an online reading group for phil of lang/logic for the semantic web.
21:34:42 <bijan> Work our way through some logic text and a standard PHil of lang ontolgoy.
21:34:43 <bijan> er...
21:34:45 <bijan> anthology.
21:35:00 <jhendler> mother-of(John) = aunt-of(Mary) without naming the person
21:35:21 <sandro> Sure, but you can't say mother-of = aunt-of.
21:35:23 <jhendler> but = is not actually in FOL, right bijan?  DOesn't it have to be defined (i.e. IFF is defined)
21:35:43 <bijan> Well, one usueally distinguish FOPC and FOPC + identity.
21:35:44 <sandro> A lot of books seem to define FOL as FOL-with-equality.
21:36:28 <jhendler> sandro - that's generally right (aunt-of and mother-of) except in some syntactic sugar in some representational schemes.
21:36:46 <bijan> So, whether it's "in" or "out" depends on your mood ;)
21:36:52 <jhendler> but that is important - and why designates might be such an interesting thing to play with...
21:36:57 <bijan> I'd be surprised if identity affected the metalogical characteristics of FOL.
21:37:23 <bijan> Sometimes, you add identity as a distiguished 2 place relation to monoadic Predicate Logic.
21:37:27 <bijan> That has advantages.
21:37:48 <jhendler> equal isn't a real problem, but of course = and NOT together have interesting properties...
21:38:13 <jhendler> bijan - yes, that's what I've always seen done, with the "=" sign being syntactic sugar
21:38:22 <bijan> yep.
21:38:51 <sandro> well, I'm about to try to tie an FOL engine to RDF.  Should be fun.
21:38:53 <jhendler> bijan - re: a logic reading group - I've been suggesting we should find a place for some folks like Pat and Peter P-S to give a tutorial 
21:39:04 <sandro> who has time to read...?  :-)
21:39:07 <jhendler> define "FOL engine"
21:39:09 <sandro> *shrug*
21:39:12 <sandro> otter
21:39:57 <jhendler> umm, I don't know otter well (URI?) assume it's a theorem prover?
21:39:58 <sandro> using it in auto mode, set for many proofs, to find (some of) the entailment of rdf(x,y,z).
21:41:03 <sandro> http://www-unix.mcs.anl.gov/AR/otter/
21:41:03 <dc_rdfig> A: http://www-unix.mcs.anl.gov/AR/otter/ from sandro
21:41:04 <jhendler> backward or forward chainer?  I've been looking for a backward chainer for RDF -- some of the ontologies I want to play with are in the millions of nodes, and thus a forward chainer isn't much help to me right now...
21:41:36 <bijan> Hmm. Need to revive CWMclone. Need to finish the subSOAP stuff first.
21:42:11 <sandro> Mostly I think XSB is the right approach, but I want try some non-horn stuff.
21:42:35 <sandro> And otter can tell me what's hornable, and give me the clauses to feed to XSB if I want.
21:42:52 <sandro> * sandro has to go do an errand.   back in a bit.
21:42:56 <jhendler> ahh, I see otter is an argonne prover, I know some of their earlier stuff.  It's resolution based, which can be very efficient.
21:51:44 <bijan> ok, I'm off.
21:52:19 <jhendler> ta - get back to that thesis writing sometime (hey - I'm a prof, bugging grad students is what I do best!)
21:54:49 <zippy> zippy has quit
21:56:39 <GabeW> GabeW has joined #rdfig
21:59:01 <jhendler> jhendler has left #rdfig
22:10:05 <sandro> sandro has quit
22:10:19 <ambient> ambient has joined #rdfig
22:11:34 <sandro> sandro has joined #rdfig
22:12:38 <sandro> sandro has quit
22:13:05 <sandro> sandro has joined #rdfig
23:16:56 <sbp> sbp has joined #rdfig
23:30:57 <SethR> SethR has joined #rdfig
23:32:02 <SethR> i just wanted to say to sandro that i think he is right on with http://www.w3.org/2001/12/uname/
23:32:46 <SethR>  http://www.w3.org/2001/12/uname/
23:33:01 <SethR> http://www.w3.org/2001/12/uname/
23:33:02 <dc_rdfig> B: http://www.w3.org/2001/12/uname/ from SethR
23:33:26 <SethR> B:| The UNAME Predicate
23:33:27 <dc_rdfig> titled item B
23:33:55 <SethR> B: I think this is right on .. will help us merge nodes that mean the same thing
23:33:55 <dc_rdfig> commented item B
23:34:30 <sbp> * sbp seems to have missed that
23:35:25 <SethR> B: as long as we use this [http://robustai.net/ai/identity.htm|concept of identity]
23:35:25 <dc_rdfig> commented item B
23:36:37 <SethR> so what do you think sean?
23:37:31 <sbp> * sbp is wondering where these node vs. resource discussions are taking place
23:37:52 <SethR> i saw some of them in the discussions here today
23:39:24 <sbp> so I see from the logs
23:40:41 <SethR> so we can have lots of names for the same node ... just make a node and give it multiple names .. wherever you know two node refers to **exactly** same thing, you merge them
23:41:50 <sbp> But you don't have to; isn't that the gist of Bijan's intesionality point?
23:43:05 <SethR> i think bijan missed the idea that you dont merge them unless the nodes refer to ****exactly**** the same thing ... that is you go for a stronger meaning of identity
23:43:41 <sbp> B:As a property by itself, it doesn't seem to have much worth... But it's neat for creating sub properties from: log:uri, etc.
23:44:00 <SethR> otherwise you would loose info .. like for instance .. what i know about John might not be the same as what you know about John .. so those got to be different nodes
23:44:25 <sbp> I think that bijan's point is that you can never know if two nodes are exactly the same thing out-of-context. But I've only skimmed the debate (multitasking)
23:44:31 <sandro> sandro has quit
23:44:31 <ambient> ambient has quit
23:44:31 <xena> xena has quit
23:44:31 <Skyline> Skyline has quit
23:44:31 <dc_rdfig> dc_rdfig has quit
23:44:31 <hazmat> hazmat has quit
23:45:38 <sbp> s/nodes/resources/
23:46:31 <sbp> A node seems to be what you refer to as the avatar for a resource within a computer system. A resource is the actual thing (like Sowa's semantic triangle)
23:46:54 <sbp> avatar is probably the wrong word. Representation?
23:47:31 <SethR> SethR has quit
23:47:31 <mnot> mnot has quit
23:47:31 <GabeW> GabeW has quit
23:47:31 <bijan> bijan has quit
23:47:57 <sbp> Hmm... actually, I don't really get "uname". It seems that nothing could ever really have a UName, if a UName is not explicitly a URI-Ref or whatever
23:48:01 <sandro> sandro has joined #rdfig
23:48:01 <ambient> ambient has joined #rdfig
23:48:01 <Skyline> Skyline has joined #rdfig
23:48:01 <hazmat> hazmat has joined #rdfig
23:48:01 <dc_rdfig> dc_rdfig has joined #rdfig
23:48:01 <xena> xena has joined #rdfig
23:48:06 <ChanServ> [#rdfig] This channel is logged and blogged: http://logicerror.com/rdfIRCWelcome
23:48:11 <SethR> SethR has joined #rdfig
23:48:22 <SethR> something disconnected me
23:48:28 <sbp> <sbp> Hmm... actually, I don't really get "uname". It seems that nothing could ever really have a UName, if a UName is not explicitly a URI-Ref or whatever
23:49:35 <SethR> i think uname could be any literal that can name something
23:49:54 <SethR> but probably need to distinguish URI from literals
23:50:03 <sbp> if you do _:a u:uname "http://www.w3.org/" . but don't know that the literal object is actually a URI, then what's the point? It's just a name that anybody can give to anything. We may as well just use words
23:50:53 <sbp> but as I say, it's probably more useful for making sub properties out of. Then again, it's just as easy to say "this has the range of rdfs:Literal, and is of type daml:UnambiguousProperty"
23:51:04 <SethR> sure ... why not just use words ?
23:51:25 <sbp> Words are rather context dependent though, aren't they?
23:51:53 <sbp> Then again, the meaning of them must be clear enough for us to at least have a decent conversation, otherwise they'd be no good as words :-)
23:52:30 <SethR> well im assuming that this node is in some context .. so in that context i say i can use some string "......" to refer to that node .. whaere does it hurt?
23:53:05 <sbp> So it's like a bNode label?
23:53:24 <bijan> bijan has joined #rdfig
23:56:20 <SethR> yep just like a bnode label ... just like the labels i put inise the mentographic boxes
23:59:55 <GabeW> GabeW has joined #rdfig