Re: Blank nodes semantics - nominal variables? [Re: Blank nodes semantics - existential variables?]

Hi Benjamin,

Are you still working with SnT?

> For nominal variables, the variable assignment has to be
> injective/one-to-one, while for existential variables, it can be
> non-injective, can map multiple variables to the same thing.

The existence of a bijective map renaming blank node (names) is indeed
one property preserved by nominal quantifiers, yes. [side note: That
would be summed up by the "equivariance" property: nominal x. nominal
y.P(x, y)  iff  nominal y. nominal x.P(x, y). ]


> Does that make sense for RDF?
> Especially, since the semantics explicitly allows two IRIs to denote the
> same thing?
> This would surely impact the notions of Skolemization (where blank nodes
> are replaced by minted IRIs) and instance (where blank nodes are
> replaced by IRIs, literals or blank nodes) in the RDF standards.

I don't see anything that would break, since you could also Skolmise
nominal variables (something similar is done inside several
verification frameworks that use nominal quantifiers to reason about
data containing names). Maybe you could give an example of something
that might break...

I think Dieter (in the other thread) explained a key gap between
Skolemization and names (i.e., blank nodes that we treat as nominally
quantified variables) nicely. RDF is supposed to allow distributed
data sets to be joined together. If two producers Skolmise with the
same identifiers before the documents are merged then there can be a
potential name clash changing the meaning of the data, whereas
treating blank nodes as names (in the above mentioned sense) would
automatically handle any renaming required. The relevant clause of the
W3C standard is "provided that the Skolem IRIs do not occur anywhere
else." Of course, we could avoid clashes by having a new namespace for
every document to which we apply Skolemisation; but that requires
trust, coordination and extra engineering. If there is a mechanism
inside logic for doing this then why not use it... in the end the
engineers have less work to do.


> Diallowing two IRIs to denote the identical thing, would not fit at all
> with the open world assumption, in my opinion. So, we would probably
> lose Skolemization and instances if blank nodes were nominally
> quantified, since IRIs would then behave very differently from these
> nominal blank nodes.

Two blank nodes can still represent identical things, as you can
already achieve in RDF, that's not what my examples demonstrated.
E.g., you can still use owl:sameAs and build in a semantics for such
vocabularies. Two blank nodes are just not syntactically equal in the
same document, which is exactly what we want in RDF.


> As an additional possibility, they could be useful, but explaining two
> different kinds of blank nodes/variables through the whole syntax and
> semantics could also be very cumbersome.

Why two approaches? Just have one (blank nodes are names). The mixing
I was illustrating previously was in the query languages, e.g., SPARQL
queries asking for a pattern containing a blank node in one place and
a variable (which must be existential) in another place. My feeling is
that this is really close to what SPARQL already does.

E.g., how many SPARQL 1.1 implementations answer no to the following
query on the following data:

Query:   ASK { :Bob :has _:b2  :Bob :likes _:b3 }

Data:   :Bob :has _:b1  :Bob :likes _:b1

I'd be interested to know (but am out of time).

Kind regards,

Ross

Received on Thursday, 2 July 2020 15:19:36 UTC