Re: Blank nodes must DIE! [ was Re: Blank nodes semantics - existential variables?]

On Slide 20
<https://image.slidesharecdn.com/iswc2009pathayes-091028162812-phpapp01/95/blogic-iswc-2009-invited-talk-20-728.jpg?cb=1256747359>
 you say:

copying a graph onto a new surface always gets you new blank nodes, because
> a mark can only be on one surface.


Isn't that just another way of saying there's a value/reference
distinction? Value semantics are sometimes called *copy *semantics.

The value of a literal is not fully described by its properties
>

I was saying that a value is fully described by its properties *if* its
type is an instance of rdfs:Datatype, so a xsd:DateTime value described
without literal syntax for example.

why would that, even if it did make sense, imply that an ID can be ignored?
> What if the ID is used elsewhere to refer to the value?


Yeah, fair, I was a bit sloppy here. I mean it in the way that if a Circle
value happened to have a URL it's not really relevant to whether you can
fully understand the circle or not.

What? Why? I completely fail to understand your reasoning here.
>

I'm saying that if you are processing a graph that has blank nodes of type
schema:Person for example, then it would make sense to assign them randomly
generated URLs, such as ones with UUIDs. But if the graph has blank nodes
of type Circle for example, and Circle is of type rdfs:Datatype, then you
shouldn't assign URLs to those because they're already fully specified, it
would be as pointless as assigning URLs to literals.

If I'm able to do that, then literal syntax only exists as syntactic sugar
> for blank nodes whose type is an instance of rdfs:Datatype.
>
>

> When you say that a blank node has a type, do you mean what is said by a
> triple like
> _:thisbnode rdf:type rdfs:Datatype .
> ? Because all that says is that something exists which is a datatype. It
> does not assign a ‘type' to the bnode itself. And in any case, I cannot see
> how any of this means that literal syntax must be treated as syntactic
> sugar.


No, I mean blank nodes whose type is an instance of rdfs:Datatype, so a
Circle value for example, or a xsd:DateTime value described without using
literal syntax.

Basically what I'm saying is if in Swift you can distinguish:

    *class* Circle {
        center: coordinate1,
        radius: 10,
    }

    *struct* Circle {
        center: coordinate1,
        radius: 10,
    }

In RDF I feel it should be something similar like:

    circle1
    type: Circle (*class*)
    center: coordinate1
    radius: 10

    _:circle1
    type: Circle (*datatype*)
    center: coordinate1
    radius: 10

But it's not, what you actually have to do is something like:

    circle1
    type: Circle (*class*)
    center: coordinate1
    radius: 10

    "X0Y0R10"^^Circle

It seems like something is missing, and that literals are a stand-in for
that missing something.

Anthony


On Tue, Jul 7, 2020 at 8:59 PM Patrick J Hayes <phayes@ihmc.us> wrote:

>
>
> On Jul 7, 2020, at 9:40 PM, Anthony Moretti <anthony.moretti@gmail.com>
> wrote:
>
> Guess I'm saying two things.
>
> The first:
> type: rdfs:Datatype should be a way that consumers of a graph can
> understand that value semantics apply
>
>
> The value/reference distinction simply has nothing at all to do with RDF
> or RDFS, which aren't programming languages.
>
> , that if they like they can ignore any ID if it exists, that the value is
> fully described by its properties.
>
>
> The value of what? The value of a literal is not fully described by its
> properties, it is given by the specification of the datatype, externally to
> RDF. The meaning of xsd:number is defined in the XML Schema specification
> document, for example.
>
> But in any case, why would that, even if it did make sense, imply that an
> ID can be ignored? What if the ID is used elsewhere to refer to the value?
>
> It should be a way for publishers of a graph to say all that without
> having to create an accompanying literal syntax.
>
> In Swift for example, I can say either of:
>
>     *class* Circle {
>         center: coordinate1,
>         radius: 10,
>     }
>
>     *struct* Circle {
>         center: coordinate1,
>         radius: 10,
>     }
>
> The first implies reference semantics, the second value semantics.
>
>
> I am afraid I do not know Swift, but if you are using this terminology in
> the way I think you are, this simply does not make sense when talking about
> RDF, which isn’t about datastructures at all.
>
> So if I'm able to use rdfs:Datatype in that way, then during processing,
> blank nodes whose types are instances of rdfs:Class should be given a URI
> (using UUIDs for example), but blank nodes whose type is an instance
> (singular) of rdfs:Datatype shouldn’t.
>
>
> What? Why? I completely fail to understand your reasoning here. Whatever
> that way of using rdfs:Datatype is, it has nothing to do with RDFS (that I
> can understand, anyway.) I mean, this would not follow even in Swift, seems
> to me.
>
> The second:
> If I'm able to do that, then literal syntax only exists as syntactic sugar
> for blank nodes whose type is an instance of rdfs:Datatype.
>
>
> When you say that a blank node has a type, do you mean what is said by a
> triple like
>
> _:thisbnode rdf:type rdfs:Datatype .
>
> ? Because all that says is that something exists which is a datatype. It
> does not assign a ‘type' to the bnode itself. And in any case, I cannot see
> how any of this means that literal syntax must be treated as syntactic
> sugar.
>
> Pat
>
>
>