- From: Seaborne, Andy <andy.seaborne@hp.com>
- Date: Thu, 06 Jan 2005 11:46:34 +0000
- To: Pat Hayes <phayes@ihmc.us>
- CC: Steve Harris <S.W.Harris@ecs.soton.ac.uk>, public-rdf-dawg@w3.org
Pat Hayes wrote: > I would suggest that the simplest way for us to go would be to say that > if any arguments are unbound, then any operator is false. So if ?x and > ?y are unbound then neither of ?x=?y, ?x!=?y are true. > > Notice that we don't need to give these a value in the unbound case: all > we need to know is that they are not true in this case, so if a > constraint has them in it, then it fails. Our logic is always 2-valued, > and the values are <true> and <anything other than true> For all the operators we take from F&O, I agree that any unbound variable should make the operator false. For extensibility, to any datatypes, we allow other operators - any operator is just a filter that says "yes" or "no" to a solution, based on some variables of the solution. The corner case is an operator to test whether a variable is bound. I'm not sure this is very important to include though - a little rearrangement can get the right effects if the operator returns false rather than making the whole expression it is involved is as false: e.g. solutions with people's ages less than 21 or not specified. Either "unbound(?age) || ?age < 21" or "! (?age >= 21)" This could be seen as operators taking names of variables; the F&O operators all dereference their variables and work on the values. Andy ------------------ Pat Hayes wrote: >> On Wed, Dec 22, 2004 at 05:26:01PM +0000, Andy Seaborne wrote: >> > >Yes, but SQL for eg. has tri-value logic (true, false and NULL), so you >> > >can meaningfully apply operators and functions to unbound values >> (NULL). >> > >> > It doesn't quite work out that simply. It's fine for operators and >> > functions but pattern matching isn't so straight forward. >> > >> > OPTIONAL (<x> ?p ?o) >> > (?o ?q <y>) >> > >> > so ?o may be NULL then we have the (?o ?q <y>) and it needs to handle >> > ?o = NULL differently. NULL is different. >> >> Yes, bun in RDF you cant have a triple like (NULL ?q <y>), so that match >> will always fail. Unless I'm missing something. >> >> > Talking about NULLs, with all it special cases for matching and function >> > handling, like NULL != NULL, is no different to talking about unbound >> > variables. Both need special handling. >> >> There are no special cases. Any arithemtic operation involving NULL is >> NULL, so NULL == NULL is NULL, NULL > 3 is NULL, ... > > > OK, that is 'weak' 3-valued logic. Is there/ any/ way to write an > expression whose value is true when its argument is NULL? If not, then > NULL is just a kind of universal error-mark, and does not really change > the underlying logic; it just makes everything more complicated and > messier to state, and provides no useful functionality. In fact it is > not really a value in the usual sense at all; its really 'below' the > real values, and acts as the bottom element of a semilattice. All this > will do is create confusion when we try to define instance, matching > etc.; and I can't see that it would buy us anything positive to make up > for all the complication and confusion. > >> >> > >I have said a few times that DAWG I think should come down off the >> fence >> > >about tri-value logic. >> > >> > Do you have a test case where it makes a difference? I have difficulty >> > seeing this as other than a difference of linguistic approach, trying to >> > use the same language for matching and for operators. >> >> Yes, >> >> SELECT ?foo >> WHERE [ (?foo :p ?x) ] [ (?foo :q ?y) ] >> AND ?x != ?y >> >> In a tri-value logic, this will only succeeed if ?x and ?y are bound, I >> think. > > > There is no way to tell until someone comes up with an exact account of > what != means. But why would this case differ in a 3-valued logic from > the way it would be handled in a 2-valued logic? It only has the effect > you say because the inequality requires its arguments to be bound. We > can specify this as a constraint on the != operator without changing the > underlying logic. (BTW, there are 3-valued logics in which NULL=NULL is > true.) > >> >> > It seems to me that we have to say what happens with >> op:numeric-less-than >> > encounters anything unexpected through the casting rules of F&O extended >> > for bNodes anyway. >> >> Yes, but what. The Perl/PHP/ECMAScript convention is that >> >> ?x is unbound, ?y = 3 >> >> ?x != ?y is true >> ?x > 3 is false (for various reasons) >> >> In SQL they are both NULL, again, I think, My SQL is rusty. e.g: >> >> $y = 3; >> if ($x != $y) { print "true\n"; } else { print "false\n"; } >> if ($x > 3) { print "true\n"; } else { print "false\n"; } >> >> prints >> >> true >> false >> >> In PHP and Perl. >> >> In Perl $x > -1 is true (unbound = 0, I guess), in PHP its false. > > > I would suggest that the simplest way for us to go would be to say that > if any arguments are unbound, then any operator is false. So if ?x and > ?y are unbound then neither of ?x=?y, ?x!=?y are true. > > Notice that we don't need to give these a value in the unbound case: all > we need to know is that they are not true in this case, so if a > constraint has them in it, then it fails. Our logic is always 2-valued, > and the values are <true> and <anything other than true> > > Pat > >> >> - Steve > > > > -- > > --------------------------------------------------------------------- > IHMC (850)434 8903 or (650)494 3973 home > 40 South Alcaniz St. (850)202 4416 office > Pensacola (850)202 4440 fax > FL 32502 (850)291 0667 cell > phayes@ihmc.us http://www.ihmc.us/users/phayes >
Received on Thursday, 6 January 2005 11:47:33 UTC