[Person-ontology] Person-ontology Digest, Vol 1, Issue 11

[Parsa Mirhaji]

> The duplication driven by the need in identity management systems to be able
> to not only make statements, but also to be able to make statements about
> these statements. In Higgins call the former "Attributes" and the latter
> "Metadata" in Higgins. For example we want to make this Attribute statement
> about Digital Subject Adam: "Adam hasHairColor blonde", but we also want to
> say that this value "blonde" was provided by the Dept. of Motor Vehicles and
> has an expiration data of Jan 1, 2010.
> 
> If we just use a triple "Adam hasHairColor blonde" where blonde is a
> literal, we've no ability to make statements about the value "blonde". So
> what we do in Higgins is use two triples shown loosely here:
>   
>    Adam hasHairColor value1
>    value1 value "blonde"
>    value1 expires "Jan 1, 2010"
>    value1 source "Dept of Motor Vehicles"
> ...
>- Paul
.

If we want to assert some statements about an statement (Reification) this
is not how to do it. Your snippet doesn't say anything about the statement
but the Value1. Here is a classic reification example using blond as
xsd:string:

This is the statement about Adams hair color:
<rdf:Description rdf:about="#Adam">
    

<hasHairColor 
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">blond</hasHairColor>
</rdf:Description>

And this is its reification stating expiration dates and source of data:
<rdf:Description rdf:about="#Adam-hasHairColor">

<rdf:type 
rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement"/>

<rdf:subject rdf:resource="#Adam"/>
    <rdf:predicate
rdf:resource="#hasHairColor"/>
    <rdf:object
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">blond</rdf:object>

<expiresAt 
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">10-10-2007</expiresAt
>
    <sourceOfData
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Houston
DPS</sourceOfData>
  </rdf:Description>

 



> 
> Naively, I  wonder what you mean by value1 expires "Jan 1, 2010"
> does the blonde-ness of Adam's hair expire?
> 
> If you mean that the hair color information is known to be good on Jan 1,
> 2010, good for you,
> but I find even that confusing.
> 
> In general, this seems like some categorial error of talking about a value
> having an expiration date.
> The best I can assume from this snippet is that Adam's driver's license is
> expiring in Jan 1, 2010
> which is totally different...
> 
> David

I don't think one would evaluate semantics of some assertions on its face
value, that is, what we as a human being infer from some statement has
nothing to do with what a reasoner or application deducts from them, as it
depends on the framework and logic system used to interpret and infer and
other rules that exists in the system. There might be valid use cases for
making such assertions. For example I think that US immigration expires your
finger prints every 18 months or so (even though they are supposed to be
your unique life long companions). For such a system, any value that has
passed an expiration date should be recollected. This representation, at
minimum can support that use case, although I agree in an awkward way....

With that said, I find this method of not expressing any value simply as a
literal very useful (for reasons below), and we use this frequently. For
example one may tie literal values of such String Nodes to an NLP tool and
map its interpretation graph to the same node along with its literal value
and another rule may interpret that in the context of other knowledge and
add its inferences to the same node. Hence looking at a value node, you can
see its literal value, and all its implications through the same node...
One example of my use case for this:

Rather than directly saying [Adam hasAge "20 years"] this is what we say:

<Person rdf:ID="Adam">
    <hasAge rdf:resource="#adamsAge"/>
  </Person>

<literalValue rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >20
years</literalValue>


<rdf:Description rdf:about="#Adam">

    <rdf:type rdf:resource="#Person"/>

    <hasAge rdf:resource="#adamsAge"/>

</rdf:Description>


<rdf:Description rdf:about="#adamsAge">
    <literalValue rdf:datatype="http://www.w3.org/2001/XMLSchema#string">20
years</literalValue>
</rdf:Description>

And this is what happens after inference/rule engine plus NLP service work
on the preliminary graph:

<rdf:Description rdf:about="#Adam">

    <rdf:type rdf:resource="#Person"/>

    <hasAge rdf:resource="#adamsAge"/>

</rdf:Description>


<rdf:Description rdf:about="#adamsAge">
    <rdf:type rdf:resource="#Age"/>

    <rdf:type rdf:resource="#AgeGroup_16-25"/>

    <unit>Years</unit>
    <numericValue>20</numericValue>

    <literalValue rdf:datatype="http://www.w3.org/2001/XMLSchema#string">20
years</literalValue>

</rdf:Description>

This way, if a second system reports another age, or if in 10 years later we
measure a different age from the same system, discrepancies between reported
values are contained and we know which inference came from where....


One last note, I think redoing all XSD classes is an overkill and intended
effects could have been achieved in simpler ways (this as one example)...