Introduction

The notion of identity is a simple abstraction that enables us to construct direct, discrete statements about domains and relations of interest. However, this notion is fundamentally a limitation, forcing us to admit that descriptions made in this manner have to either deal with concepts on a fairly basic level, omitting details, variations, aspects of locality, temporality, perspective and intellectual differences, or to remodel terminology as the coverage of a domain goes into ever more specialized details.

Conventions

prefix : <https://example.org/vocab/>
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix owl: <http://www.w3.org/2002/07/owl#>
prefix skos: <http://www.w3.org/2004/02/skos/core#>
prefix quid: <https://w3id.org/quid/>

Example

Neither Stockholm nor Sweden are stable and durable patterns of energy. They are, at best, semi-perdurable sociopolitical notions correlated to activities and coarse-grained geographical measurements.

If this appears unobvious to some, consider the town of Abingdon, part of Oxfordshire since 1974, formerly of Berkshire. Or the name and parent country of St. Petersburg during the twentieth century. Or the relocation of (central parts of) the town Kiruna in the north of Sweden. Or the political status of Taiwan. (These matters indicate that borders are of the mind, not of the earth (which may arguably also be of the mind).)

Consider the case of Abingdon:

<Abingdon> :partOf <Berkshire> .

In our day and time, the above assertion is no longer a fact. Berkshire is now in the county of Oxfordshire. But it is true that Abingdon was part of the Berkshire of the 1600s and some 300 years onwards. If we were to remodel this as a spatiotemporal relationship instead, the problem of describing this fact would go away. But we would no longer have a generalized use of the term partOf, since we would in specialized situations replace that with something like:

<Abingdon> :temporalRelationship [ a :TemporalPartitiveRelationship ;
        :object <Berkshire> ;
        :earliestYear "1600" ;
        :latestYear "1974" ;
        rdfs:label "from 17c. to 1974"@en
    ] .

While arguably this is the most apt model here, there are many practical situations where remodelling or variations of terminology is not doable or desirable. You may have a stable terminology and only a few corner cases where you need to qualify certain details. In such cases, we may instead qualify identities by restricting them in one or more modalities. By qualifying Berkshire to this state, we can link to that without remodelling the relationship:

<Abingdon> :partOf [ a quid:QualifiedIdentity ;
        quid:qualifies <Berkshire> ;
        :earliestYear "1600" ;
        :latestYear "1974" ;
        rdfs:label "Berkshire from 17c. to 1974"@en
    ] .

This is the key concept that QuID formalizes. Notice that the thing is still Berkshire (which here is defined by nothing more than a nominal identifier), albeit circumstantially defined—qualified—within a scope of time.

Definitions

An Equivalent Specialization

The W3C PROV Ontology defines a notion of specialization of entities, which is effectively the same as the notion of qualification defined by QuID. Users should feel free to use the prov:specializationOf (and inverse, prov:generalizationOf) directly. The QuID ontology is mainly defined as a theoretical backbone, to elaborate on the notion and its possible use cases. Especially, it elaborates on the possibility of using qualified entities as an alternative to the use of qualified relationships, to contrast the notions and challenge their differences. The usability of this approach must of course be assessed further.

Background and Motivations

In RDF, modeling complex relationships and events is preferably done through qualification, making entities of the relationships, instead of an opaque arc, then describing the intricacies using properties and relations upon those. This is known as Qualified Relations and is a fairly common pattern (see e.g. Qualified Terms in PROV-O). It is related to the more general notion of N-ary relations, differing only in that qualified relationships are intended, through context, to primarily relate two entities (elaborating upon what cannot be captured in the triple itself, as it were).

In cases where the relationships used are preferably kept direct in one arc (one triple) with one labelled predicate, reification, is sometimes used instead. This is a complicated choice, as this is a model of the statement itself, i.e. the utterance or assertion of the relation (its fact). It purportedly steps out of the picture, attempting to speak of the assertion (and in doing so, it does not assert the triple).

This needs to be contrasted with named graphs, an established technique for chunking RDF statements into contained units, each bounded and labelled by an IRI (with the, to much chagrin, semantically undefined state in regards to denoting the graph). Barring that (or, if you will, leveraging that), this is a perfect enough vehicle for separating the depicted description from its nature as a depiction, thus making it possible to describe its strokes of paint, as it were. Marks on a paper. Claims as recorded.

(You may consider the undefined relation of the identifier of a graph and the graph itself as mirroring the relation between a picture and a name of that picture. When inscribed within itself, is it a part of the surface, or upon the surface? There is no difference, of course. It's just a collection of pen strokes in itself, and it is up to the observer to make the distinctions, by recognising the externally defined meanings of the symbols encoded by these strokes. But when it is attached to the paper, by means of a sticker, the glued-on name and the paper are of two aspects: they're the placement and part, respectively, in a pile of papers (that is, a named graph in a dataset). This is a superficial illustration of course, to exemplify that a limit to formal semantics doesn't necessarily lead to trouble, and that treating graphs from the outside as "just papers with names on them", where the name within the paper is a different thing, is actually a feature (or a freedom), engineering-wise at least.)

The Curious Case of Fact-Altering Facts

While never deprecated, reification hasn't been popularized much during the last decade or two. It's been in the background, sometimes popping up in discussions, or being used as a last resort when named graphs are considered to coarse-grained or semantically ill-defined, or when it is impractical to make multitudes of graphs if, for some reason, each triple needs to be intricately and uniquely decribed.

In 2019, reification came back into focus through RDF-star, which again tackles this modelling by making statements about statements.

Potentially problematic, it appears that in the RDF-star practise (conveyed through examples), specifically its form of annotated statements, which are asserted, there is no clear and consistent distinction between the statement and the observation which it describes. This presents an interesting potential conflation, in that statements about the statement easily veer from the arc, the act of stating something, to its implied notion, a state or an event, propositioned by the assertion. Therefore, e.g. timestamps upon the arc sometimes appear to be about the event, that is of having a relationship established (such as becoming a member of something). This appears to be a problematic distinction to maintain, and one which lots of the examples in the RDF-star mailing list appear decidedly dependent upon.

Now, it can be argued that while there is a distinction between the statement (by someone) and the observation (as a state of affairs, not necessarily observed by the same someone), it is not relevant, nor, depending on notions of perspective, a stable distinction. They may be unidentical but commonly isomorphic. However, formal definitions of statements, and their reification, goes to great length to claim that this distinction is crucial. Therefore, given the proliferation of examples which goes against it (by qualifiyng the relation rather than speaking of its assertion (as marks on paper)), it may be deemed that a practise of gaming these mechanisms is emerging here.

(Cf. "surface and depth" as discussed at length by Gilles Deleuze in Logic of Sense, who did also proclaim a profound difference between results of an event and the event itself, which is of a second degree beyond simulacra, idols and images, hinting at the collapse into conflation inherent in the conceptualising of the event on the same level as the outcome, if you're into that kind of metaphysical reasoning.)

The gist of this problem is that it is not apparent whether an assertion is or is not affected by further assertions about that assertion. Compare this to QuID, where a qualified identity by definition is restricted to its stated modalities, be it in time, space or any other point of interest. It does not touch the veracity of an assertion (it cannot, being within the same picture that it would otherwise purportedly self-validate), it just symbolizes the (inescapable albeit commonly implicit) qualification of the identity of an object in a specific contextual modality.

Further, in order to make reifications like this practical (engineering-wise), RDF-star extends the triple model. The effect of implementing that goes further than just adding a syntactic construct, as the core of the model now has to cater for this, all the way down. Even with backwards-compatible support for "just" triples as a base, the new way turns the substrate inside out, so to speak, and makes every triple susceptible to potentially deeply complex, nested reifications. While this affects the core of every RDF implementation present and future, this alteration isn't necessarily the big problem here. The main issue is that this does not happen within the simple confinement of triples (which can be confined and chunked as units of descriptions in named graphs), but inexorably mixes the triple model with the "outside the box" notion hitherto kept at the "picture frame" level of named graphs. That is a strange loop indeed, which implies that there are "fact-altering facts", rather than keeping it all as "assertions", easy enough to reason about. RDF-star effectively defines a hypergraph, which has been shown to increase computational complexity. There is no simple triple substrate anymore, as the triples themselves can be part of other triples (recursively, making this new model quite entangled). This may be desired for certain reasons, but the cost in terms of application and, more crucially, comprehension, must be thoroughly assessed.

From a user's perspective, practically, during describing activities (often using interfaces rather than specialized syntax), nesting (or when to nest) descriptions can be tricky in itself. The notion of blank nodes themselves, unnamed entities, which can be used in syntactic representations to do nesting, takes some getting used to. A different kind of nesting is likely to be difficult to expect to be consistently applied, especially when its nuance is hard enough to formulate through applied domain-specific semantics (that is, the chosen vocabularies/ontologies in use). For instance, a notion of "when" or "where" on a statement may refer to either the uttered assertion (mention) or the observed state of affairs (use), and further definition of the term is required to pin down the expected meaning, as well as diligence in its application to avoid veering from the expected interpretation of the subsequent receiver. We're back into httpRange-14 territory again; this time around potentially for every statement. While punning may theoretically come to the rescue, it didn't really manifest in property definitions everywhere to clarify the document/documented differences, so it does not appear likely to clear things up for reified statements either.

With all that said, it must be equally assessed whether the notion of a qualified identity is actually more comprehensible than "fact-altering facts". The latter may be a picture within a picture, but the former is, admittedly, nevertheless a drawing tool for idiomatically skewed illustrations. The major difference here is about whether to remake the technical substrate to accommodate for the design, and which idea and connected user stories is actually easier to teach and maintain in practise. This requires careful comparison with thorough evaluation. QuID is conceived of as a contrasting alternative, striving for increased awareness of implications and comprehension.

Dissolving Simple Semantics

It should also be noted that there is virtually nothing in the QuID design which caters for the Property Graph notion of annotatable multiset arcs, the aligning of which has shown to be a major incentive in the advancement of RDF-star. This seems to be one major influence in the veering towards conflation of assertion and observation which results in the aforementioned dissolution of the triple substrate (pulling out the carpet from beneath our feet, if you will). And that state of affairs is basically what the stage of Property Graphs is like, with invent-your-own semantics lacking a simple, formal model (much like where "just XML and XLink" is at, lacking the effective and simple semantics of RDF, as do most forms of hyperlinks in JSON except for JSON-LD, the latter being grounded in RDF). The QuID notion is just an application of RDF, to avoid that dissolution. You may still attach custom properties to a qualified identity of course, and you may very well model qualified relations in RDF without this notion of nested identities, if your data calls for that.

Everything Is An Event

Most if not all of the problems that this gaming of reification of relationships and properties attempt to solve stem from avoiding to model and describe events themselves. This is arguably better in general, logically, but forces the applied vocabulary to incorporate terms describing a deeper level of granularity. It also only conceptualises time (and possibly space through locations, though as shown locations other than coordinates are hard to pin down).

Everything Is From A Point Of View

Compare this to QuID, which is about identifying a qualified state of an entity. This state can be as varied as needed, temporally, spatially, intellectually, culturally or any other dimension of the domain of interest. Points of view, states of mind, even states of captured descriptions of things, are all valid and of equal standing to this model. This is just the nature of our substrate of statements, being fundamendally grounded in our varyingly discrete (as in varyingly granular and therefore ultimately limited) conceptual notions, expressed through finite vocabularies.

This means that instead of attempting to describe the statement (in cases where the event is not explicitly modelled), and somewhat conflating the statement with the event, QuID models the states of the identities of the relationship, therefore capturing the essential characteristics of the event through its constituents. While this is not without its own limitations, it is doing so within the simplicity of the regular model of triples. It is also not a replacement for modelling events where those are needed; when such needs are apparent it is very much preferred to do so. Furthermore, this modelling is not in any way limited to events (as temporal entities), but is just as applicable to other modalities, such as points of views, spatial or compositional variations, levels of generality or specificity in any conceivable kind of dimension or perspective.

Does this not present similar problems as applied reification, in terms of vagueness? Yes and no; yes it goes into the territory of vagueness, and may very well be used for radically idiomatic notions of identity. But it does so explicitly, by design, in that it formally charges the identity as contextually qualified, and this context can only be interpreted properly by understanding the statements about the qualified identity. It is explicitly defined by its extension of description. (Arguably, this is the case for every identity whatsoever, but since that is not exhaustively recognized, we cannot universally expect that.) Therefore, the presence of a quid:qualifies property on any entity immediately conveys its nature as a qualified identity, meaning that it is of the same kind, but of a narrower nature than the thing qualified; and that this narrower nature is conveyed through the other properties if it.

A principal point is this: qualified identities are on equal ground with the properties relating and describing them. Just as these properties are inevitably limited by their own definitions (and extensions through usage), the identities they capture are as well. They are bound together in the same semantic fabric, if you will, and that ultimately limits what they express. That is the gist of symbols, and of identities.

Use Cases

It is important to understand that some of these selections are made to show-case the aforementioned gaming of reification to express event-like or circumstantial relations, and how the sought after meaning could be expressed using qualified identities rather than annotated arcs (both of which often suffer from a lack of a more expressive terminology).

As already discussed, many of these cases are probably better modelled using events. But as the cases have been defined, the task at hand is to model them without new terms for the relationships.

Some of these examples use rdfs:label to explain what the quid:QualifiedIdentity captures. This is only for clarification, and isn't a necessary or even expected pattern.

Also note that the explicit use of quid:QualifiedIdentity is occasionally left out, since the rdfs:domain definition of quid:qualifies implies it.

(Notice how isomorphic these examples are to the annotation syntax of RDF-star. Notice also the fundamental difference in terms of what they mean in triples, respectively. The annotation form means asserted triples with no qualification, on the one hand, and, formally, triples about those triples. The qualified identities are just described using triples, as shown. What you see is what you get.)

<liz_taylor> :married [ a quid:QualifiedIdentity ;
    quid:qualifies <richard_burton> ;
    :role :husband ;
    :year 1964 ;
    :location <montreal> ;
    rdfs:label "Richard Burton at 1964 in Montreal, becoming a husband"@en ;
    rdfs:comment "possibly being slightly inebriated"@en ;
    :source [ quid:qualifies <thePeeragePerson/p33443.htm#i334430> ; :retrieved "2020-08-07" ]
  ] .

<liz_taylor> :married [ a quid:QualifiedIdentity ;
    quid:qualifies <richard_burton> ;
    :year 1975 ;
    :location <botswana>;
    rdfs:label "Richard Burton at 1975 in Botswana"@en ;
    rdfs:comment ""Very much in love with Liz Taylor"@en
  ] .

<Full_Fact> :member_of <IFCN> .

[
  quid:qualifies <Snopes> ;
  rdfs:label "Snopes between 15 April 2017 and 5 June 2019 according to X at 9 Dec 2021"@en ;
  :started "2017-04-15" ;
  :ended "2019-06-05" ;
  :source [ quid:qualifies <X> ; :at "2021-12-09" ]
] :member_of <IFCN> .

<#alice> :workingFor [
    quid:qualifies <#acme> ;
    :since "2012-03-04"^^xsd:date;
    :until "2018-09-10"^^xsd:date;
    :accordingTo <//acme.com/staff.html>
  ] .

<#car123>
 :driver <#alice> ;
 :owner [ quid:qualifies <#acme> ; :since "2019-06-01"^^xsd:date ] ;
 :parkedIn [
    quid:qualifies [ geo:longitude 4.86553; geo:latitude 45.78234 ] ;
    :observedAt "2019-10-03T12:34:56Z"^^xsd:dateTime ].

<#cartoon1> :depicts [
      quid:qualifies <#bob> ;
      :state :sleeping ;
      :dreamingOf [
          quid:qualifies <#alice> ;
          :dreamingOf <#bob>
        ]
  ] .

[
    rdfs:label "Later Wittgenstein"@en ;
    quid:qualifies <Wittgenstein> ;
    :at "193X"
] :arguedAgainst [
    rdfs:label "Early Wittgenstein"@en ;
    quid:qualifies <Wittgenstein> ;
    :at "192X"
] .

</item/1> :hasTitle [
    quid:qualifies [ :mainTitle "Item One" ;
                 :subtitle [ quid:value "an item" ;
                             :addedIn <rev3> ] ] ;
    :addedIn <rev2> ] ;
  a [ quid:qualifies :Thing ; :addedIn <rev2> ; :removedIn <rev3> ] ,
    [ quid:qualifies :Item ; :addedIn <rev3> ] ;
  :relatedTo [ quid:qualifies </item/2> ; :addedIn <rev2> ; :removedIn <rev3> ] ,
             [ quid:qualifies </item/3> ; :addedIn <rev3> ] .

prefix r: <./reification#>

r:statement owl:inverseOf rdf:subject .

</item/1> r:statement [
    rdf:predicate :hasTitle ;
    rdf:object [ :mainTitle "Item One" ;
          r:statement [ rdf:predicate :subtitle ;
                   rdf:object "an item" ;
                   :addedIn <rev3> ] ] ;
    :addedIn <rev2> ] ,
  [ rdf:predicate rdf:type ; rdf:object :Thing ; :addedIn <rev2> ; :removedIn <rev3> ] ,
  [ rdf:predicate rdf:type ; rdf:object :Item ; :addedIn <rev3> ] ,
  [ rdf:predicate :relatedTo ; rdf:object </item/2> ; :addedIn <rev2> ; :removedIn <rev3> ] ,
  [ rdf:predicate :relatedTo ; rdf:object </item/3> ; :addedIn <rev3> ] .

Defining Qualifications

A challenging aspect of this design is about how to control, in editing and validation, what the qualification of something is. It is possible to use quid:QualifiedIdentity as a mixin for definining qualifications as subclasses of some given concrete class. These constrained classes can then be used with either owl:Restriction on existing properties, or in conjunction with specific properties defined for the given level of qualification, connected to the concrete, qualified class using rdfs:domain (or rdfs:range for properties linking to the kind of qualified things defined).

Example:

:MomentaryThing a owl:Class ;
  rdfs:subClassOf quid:QualifiedIdentity .

:since rdfs:domain :MomentaryThing .
:until rdfs:domain :MomentaryThing .

:MomentaryPlace a owl:Class ;
  rdfs:subClassOf :Place, :MomentaryThing .

:MomentaryPerson a owl:Class ;
  rdfs:subClassOf :Person, :MomentaryThing,
      [ a owl:Restriction ;
        owl:onProperty :location ;
        owl:allValuesFrom :MomentaryPlace ] .

Application

Where qualification nuances are to be glossed over for casual use cases ("list all Ps for an S, regardless of details"), a kind of dumbing down of the indirection would be convenient, to get back to the naive level which was the original limitation in the choice of properties (direct relations over qualified forms).

In SPARQL, using property paths is simple enough when you want to find all things related through a property (here partOf), regardless of any qualified notion (e.g. unconfined to perspectives like temporality).

Consider these, based on earlier examples:

SELECT * {
  <Abingdon> :partOf/quid:qualifies* ?historical_or_contemporary_region .
}

SELECT * {
  <liz_taylor> :married/quid:qualifies* ?spouse_past_or_present_purported_or_imagined .
}

The choice of quid:qualifies* here over just quid:qualifies? is to accommodate for the possibility of a chain of qualifications in a general setting. Depending on application practises, this can be simplified or even abstracted away.

It is currently advised to handle this in the application layer, to enable end users (e.g. description creators) to utilize these forms without forcing other users (e.g. consumers) having to do much extra work to cope with them. Naturally, the distinction between qualified and direct relations is available for those who need it. This is similar to how some applications can follow skos:broader chains up and down to facet match on topics arranged hierarchically.

If the qualification approach appears valuable (which the related designs below might indicate), it would be worthwhile to incorporate it into RDF toolkits, akin to identity smushing of owl:sameAs assertions performed in some (but far from all) RDF libraries. Or perhaps explicitly but conveniently like how rdf:List as a triple representation of linked lists is commonly wrapped as regular ordered lists in most if not all RDF object models and toolkits.

Note that this is intended to preclude the need for reasoning using e.g. OWL property chain axioms to get at the simple picture. That said, there may be a need to map qualified identities to actual qualified relations. This would be a worthwhile next step, and one which would remove an odd pattern today of gaming RDF reification to get at e.g. an indirected property by attempting to semantically map e.g. a bf:role property to rdf:predicate (or as once seen in AtomOwl for modelling detailed links).

Relationship To Other Designs

The pattern defined by QuID is by no mean novel. It is inspired and informed by lots of prior work, and is at best an attempt at formalizing a common intersection of these.

Specialization of

The prov:specializationOf relation defined by W3C PROV-O is a basis for quid:qualifies. QuID is a focused, standalone definition, comprising just a small piece of PROV, and users might find value in this, along with its defined class for qualified identities. In general though, these are considered to be interchangeable.

Value

rdf:value is in its earliest usage (as exemplified by DCMI) almost alike quid:qualifies. But since it is (almost) exclusively used to provide a literal value in an informal Structured Value pattern, it is not the same. Therefore, QuID defines quid:value as a sub-property of rdf:value, to formalize qualifications of literals.

Same As

Obviously owl:sameAs denotes the same thing, by declaring an alternate symbol for the same identity. The similarity to quid:qualifies is confined to cases of mechanical treatment of indirection in non-reasoning RDF applications, where the different qualifications are not interpreted, and the relation is simply followed to gather more data about a given resource.

Broader

Similarly, skos:broader can be considered an indirection. Interestingly, quid:qualifies is similar also in that it relates a more general notion. Crucially though, with QuID, this notion is still within the same identity. So at most, there is a super-property relation here (which also is defined).

Exact Match

By contrast, skos:exactMatch is an indirection mainly, perhaps only, in conceptualization, and in many other ways represents a shared identity. However, the specific semantics of SKOS here regarding the two identities being separated by skos:ConceptScheme makes the relation to quid:qualifies less exact (they're more of an exact match...). The latter may very well relate identities within the same concept scheme, if any at all.

Focus

The relationship established between a skos:Concept and a real thing by foaf:focus is conceptually similar to quid:qualifies. But there is no distinction between the natures (types) of the subject and object in the former. On the contrary, when using quid:qualifies, its subject and object share the same core type, with the former merely being more qualified (as in specific, or precise, or any other kind of modal restriction, down to being a mixed quotation). With foaf:focus, the relation is between a conceptualization and its conceptualized thing.

Role

The usage pattern defined by schema:Role is quite similar to the pattern established here. They both represent applied semantics for the qualification pattern, albeit with some clear differences. For one schema:Role uses the rather odd notion of repeating the relation to it to reference the actual object. That makes for some rather illogical interpretations for some relations (for instance a ownedBy relation to a Role qualifying it would require stating that this role is itself ownedBy the owner, rather than being an intermediary form of the object). And again, the Role is definitely of a different type than the indirected thing.

Nomen

As defined, the LRM Nomen

can be understood as the reification of a relationship between an instance of res and a string

Also, Haddocks' Eyes comes to mind, a poem sung by The White Knight to Alice in Lewis Carroll's Through the Looking-Glass.

• The song's name is called Haddocks' Eyes.
• The song's name is The Aged Aged Man.
• The song is called Ways and Means.
• The song is A-sitting on a Gate.

Which could be encoded like:

<Haddocks+Eyes> a :Name ;
  rdfs:label "Haddocks’ Eyes" ;
  rdf:value "The Aged Aged Man" ;
  :of <Ways+and+Means> .

<Ways+and+Means> a :Song ;
  rdfs:label "Ways and Means" ;
  rdf:value "A-sitting on a Gate" .

It wouldn't make much sense to model this using QuID.

Things As Concepts

The notion of qualified identities can be construed as presenting a world view where the notions of owl:Thing and skos:Concept become effectively the same. However, as these are not defined so, this is just a philosophical interpretation beyond their defined semantics. Whether a quid:QualifiedIdentity is more or less conceptual requires a philosophical analysis with no clear outcome to be expected.

Suffice to say, in this alluded world view of QuID, the only accurate description of the world is, as far as physicists can tell, the representation comprised of something along the order of 3.28 x 10⁸⁰ quarks, assuming a Planck-sized substrate and excluding every multidimensional complication like brane theory and whatnot. Every less accurate description is merely a useful fiction. (Perhaps everything is.)