Proposal: add properties that represent taxon relationships

[camwebb]

(Following from a short discussion at today's 2020-06-30 video call...)

In TCS1, the TDWG TaxonConcept ontology, and our draft Terms document, the only way to express the relationship between two taxon name usages (or taxon concepts) is via the creation of an instance of the TaxonRelationshipAssertion class. While this reification of the relationship is the only way to attach an accordingTo (at least in a table or in RDF), it is cumbersome (see, e.g., this figure). The accordingTo is also redundant in the case of a dataset representing a taxonomic monograph, where all such assertions are being made by a single author in a single publication. For simpler modelling of TNU relationships, I suggest that some users would value a standardized alternative in which the relationship types were themselves properties of a TNU. For example:

:TNU1 tcs2:is_congruent_to :TNU2 .
:TNU1 tcs2:includes :TNU3 .

These new properties would be added to the properties section of the TCS2 Terms document.

[mdoering]

It opens up the standard for alternative representations. This shifts the problem to consumers that now have to check different places for the same information. I personally think this is a bigger problem than for the producer, so I would try to avoid this as much as possible. It is also an issue you find in DwC, ABCD and TCS1 where there are parsed and unparsed strings for the same thing. The more options a standard has, the less of a standard it is :)

[camwebb]

@mdoering Good point. I concede that for standardization of data transfer, having a single way to 'officially' do something is best.

[nielsklazenga]

I transferred this issue from the TNC repo. a few weeks ago, because I think we should consider making the relationship types TCS properties, rather than controlled terms in an external vocabulary. I actually think we should do it, but I have been flip-flopping around on this issue a bit (privately; publicly I think this is the first time I am saying something about it). At the moment I even think we can do without the Taxon Relationship class altogether, but we might need it again when we want to add additional properties like whether the statement reflects the ostensive or intensional component of the relationship. On the other hand, that might be the time to add the class, rather than now.

Having the relationship types as TCS properties enables us to do things like this:

<https://id.biodiversity.org.au/instance/apni/545068> a tcs:TaxonConcept ;
  dcterms:title "Euphrasia gibbsiae sec. Barker 1982" ;
  tcs:accordingTo <https://www.jstor.org/stable/23873848> ;
  tcs:acceptedName <https://www.ipni.org/n/802545-1> ;
  tcs:synonym <https://www.ipni.org/n/802619-1> ;
  tcs:intersects <https://id.biodiversity.org.au/instance/apni/713514> .

<https://id.biodiversity.org.au/instance/apni/713514> a tcs:TaxonConcept ;
  dcterms:title "Euphrasia gibbsiae sec. Curtis 1967" ;
  tcs:accordingTo <https://id.biodiversity.org.au/reference/apni/23028> ;
  tcs:acceptedName <https://www.ipni.org/n/802545-1> .

... and, for a third-party taxon relationship assertion, in the body of an annotation or a nano-publication:

_:someone_elses_assertion a rdf:Statement ;
  rdf:subject <https://id.biodiversity.org.au/instance/apni/545068> ;
  rdf:predicate tcs:includes ;
  rdf:object <https://id.biodiversity.org.au/instance/apni/713514> .

I think I might be committing RDF sacrilege with the latter example, but this is just how I think it could work and someone else can correct me.

I think doing this makes TCS 2 more simple and flexible and more like a proper TDWG vocabulary standard, i.e. a set of terms and definitions.

I acknowledge that it is rather late in the game to make significant changes, so if we cannot quickly agree on this we will table it, but if we can we might as well get it right from the start, so let's at least talk about it. At least at the moment I think this is right. Defining taxon relationship assertions as "Things" has always bothered me for some reason – and we have had some issues with naming the class (#43) – and now I think that might be because they are mere data structures and should not have a domain-specific class. Relationships between objects are generally recorded using properties. I also think it is not that much of a change and possibly a big improvement.

[camwebb]

I've always disliked the existing implementation of TC Relationships with the 'From' and the 'To' TCs, and agree in simple cases making the relationship types into different properties would be cleaner and simple. But... in our case, almost always we want to encode the 'according to' of the relationship - who asserted it. Which would mean reifying the statement every single time. I think the essence of the issue this: will there almost always be metadata about the TC relationship that needs to be encoded in the data transmission model? If so, we should probably stick with what we have.

The problem is a generic one with modelling in RDF. Graph DBs (and their ASCII encodings) allow edges to have properties, which permits a more 'natural' graph. In RDF you always need an intermediate node to hang edge metadata on. I'm sure there has been extensive discussion of the pros and cons of writing a schema such that reification must always be used (for full data transmission). In practice, I haven't seen reification used as a core technology.

[nielsklazenga]

Hi @camwebb, have a look at the examples I put in https://github.com/tdwg/tcs2/tree/examples-stash/docs/examples/taxon-relationships-redone. As this branch will disappear at some point, I will repeat some here for the sake of longevity.

So, a Taxon Concept with horizontal relationships between taxa looks like this:

@prefix tcs: <http://rs.tdwg.org/tcs/terms/> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

[] a tcs:TaxonConcept ;
    dcterms:title "Campylium sec. Koperski et al. 2000" ;
    tcs:accordingTo <https://tropicos.org/reference/9022656> ;
    tcs:acceptedName <https://tropicos.org/name/35000208> ;
    tcs:synonym <https://tropicos.org/name/35101378> ,
            <https://tropicos.org/name/35101264> ;
    tcs:isConguentWith [ a tcs:TaxonConcept ;
            dcterms:title "Campylium sec. Corley et al. 1981" ;
            tcs:accordingTo <https://tropicos.org/reference/9004554> ;
            tcs:acceptedName <https://tropicos.org/name/35000208> ] ;
    tcs:includes [ a tcs:TaxonConcept ;
            dcterms:title "Campylium sec. Smith 1980" ;
            tcs:accordingTo <https://tropicos.org/reference/9007023> ;
            tcs:acceptedName <https://tropicos.org/name/35000208> ] ;
    tcs:partiallyOverlaps [ a tcs:TaxonConcept ;
            dcterms:title "Chrysohypnum sec. Moenkemeyer 1927" ;
            tcs:accordingTo <https://tropicos.org/reference/9021085> ;
            tcs:acceptedName <https://tropicos.org/name/35000256> ] ,
        [ a tcs:TaxonConcept ;
            dcterms:title "Drepanocladus sec. Moenkemeyer 1927" ;
            tcs:accordingTo <https://tropicos.org/reference/9021085> ;
            tcs:acceptedName <https://tropicos.org/name/35000413> ] ;
    tcs:intersects: [ a tcs:TaxonConcept ;
            dcterms:title "Campylium sec. Frahm & Frey 1992" ;
            tcs:accordingTo <https://tropicos.org/reference/9011497> ;
            tcs:acceptedName <https://tropicos.org/name/35000208> ] ;
    rdfs:comment """Weltweit über 30 Arten, in Europa 9 Arten (incl. *C. 
            laxifolium Engelmark & Hedenäs 1990) – Hedenäs (1997a) akzeptiert 
            auch die Gattungen Campyliadelphus und Campylophyllum und stellt 
            Campylium polygamum zur Gattung Drepanocladus.""" .

One of these relationships, with a comment, looks like this:

@prefix tcs: <http://rs.tdwg.org/tcs/terms/> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

[] a rdf:Statement ;
    rdf:subject _:tc-2000-Campylium ;
    rdf:predicate tcs:includes ;
    rdf:object _:tc-1980-Campylium ;
    dcterms:source <https://tropicos.org/reference/9022656> ;
    rdfs:comment """excl. *C. longicuspis (Lindb. & Arnell) Hedenäs (syn. 
            *Amblystegium l. Lindb. & Arnell, *Drepanocladus l. (Lindb. & 
            Arnell) Broth., Pseudocalliergon l. (Lindb. & Arnell) Loeske), da 
            Hedenäs diese Kombination erst 1989 schuf. Es bleibt unklar zu 
            welcher Gattung SMITH dieses auf den Britischen Inseln nicht 
            nachgewiesene Taxon stellt""" .

I came across the RDF Reification Vocabulary serendipitously when I happened to read the RDF Schema specification, but it turns out @baskaufs had already suggested using it two years ago, in a presentation at TDWG 2021, to deal with dwc:ResourceRelationship statements in RDF (see here and here; I think the 'having your cake and eating it...' in the title is really apt).

Regarding your statement that you 'haven't seen reification used as a core technology', I think that is not true, as you are using reification whether you use the Vocabulary or not, so we were already using reification for the relationships between taxa. Especially when serialising as tabular data – and storing data in a relational database – reification is used all the time to resolve many-to-many relationships. Also, serialisation should not be a concern of a Vocabulary Standard, which is one of the reasons why we are having so much trouble with the dwc:ResourceRelationship (and by extension the tcs:TaxonRelationship) and it is also why we want to free TCS from its XML Schema. Your data might force you to use reification, but TCS should not.

I am not opposed to still having a TaxonRelationshipAssertion or TaxonConceptAlignment class in TCS, quite the opposite, as it has a special purpose for us. I think it is akin to creating a special Extension for the Darwin Core Archive, rather than using the ResourceRelationship extension (which is why I am in two minds about this, as that comes into Application Profile territory). This is something I want to discuss in the TG (in the first instance). It is the subjectTaxonConcept, relationshipType and objectTaxonConcept properties I really want to get rid of, as they are boilerplate (and syntactic sugar), which has no place in a domain Standard like TCS, I think.

[nielsklazenga]

TCS 1 has TaxonRelationshipAssertion as a top level element (same level as TaxonConcept and TaxonName), so removing it would be a change to the Standard. Which makes the decision easy, I think.

With that, the proposal is simply as follows:

1. Instead of having a separate controlled (SKOS) vocabulary for relationship types, define the relationship types as properties in TCS.
2. Instead of defining the syntax properties subjectTaxonConcept, relationshipType and objectTaxonConcept in TCS, borrow the subject, predicate and object properties from the RDF namespace.

The first dot point is the original GitHub issue (#225), although I think that proposed to have both the SKOS vocabulary and the TCS properties. This brings TCS 2 closer to TCS 1, as in TCS 1 the taxon relationships could also be embedded in the Taxon Concept.

Additionally, rather than defining a TCS property relationshipAccordingTo, I would like to borrow dcterms:source from Dublin Core (@baskaufs uses prov:wasDerivedFrom in his Resource Relationship examples). I would also like to borrow dcterms:creator and dcterms:created for when there is no source as such.

So, the example before becomes:

@prefix tcs: <http://rs.tdwg.org/tcs/terms/> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

_:tc-2000-Campylium a tcs:TaxonConcept ;
    dcterms:title "Campylium sec. Koperski et al. 2000" ;
    tcs:accordingTo <https://tropicos.org/reference/9022656> ;
    tcs:acceptedName <https://tropicos.org/name/35000208> ;
    tcs:synonym <https://tropicos.org/name/35101378> ,
            <https://tropicos.org/name/35101264> ;
    rdfs:comment """Weltweit über 30 Arten, in Europa 9 Arten (incl. *C. 
            laxifolium Engelmark & Hedenäs 1990) – Hedenäs (1997a) akzeptiert 
            auch die Gattungen Campyliadelphus und Campylophyllum und stellt 
            Campylium polygamum zur Gattung Drepanocladus.""" .

[] a tcs:TaxonRelationshipAssertion ;
    rdf:subject _:tc-2000-Campylium ;
    rdf:predicate tcs:includes ;
    rdf:object [ a tcs:TaxonConcept ;
            dcterms:title "Campylium sec. Corley et al. 1981" ;
            tcs:accordingTo <https://tropicos.org/reference/9004554> ;
            tcs:acceptedName <https://tropicos.org/name/35000208> ] ;
    dcterms:source <https://tropicos.org/reference/9022656> ;
    rdfs:comment """excl. *C. longicuspis (Lindb. & Arnell) Hedenäs (syn. 
            *Amblystegium l. Lindb. & Arnell, *Drepanocladus l. (Lindb. & 
            Arnell) Broth., Pseudocalliergon l. (Lindb. & Arnell) Loeske), da 
            Hedenäs diese Kombination erst 1989 schuf. Es bleibt unklar zu 
            welcher Gattung SMITH dieses auf den Britischen Inseln nicht 
            nachgewiesene Taxon stellt""" .

...and assertions without a source look like:

@prefix tcs: <http://rs.tdwg.org/tcs/terms/> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

[] a tcs:TaxonRelationshipAssertion ;
    rdf:subject <https://avibase.ca/82745BAA> ;
    rdf:predicate tcs:includes ;
    rdf:object <https://avibase.ca/F558C7F9> ;
    dcterms:creator <https://orcid.org/0000-0003-2224-6821> ;
    dcterms:created "2023-07-31" .

[] a tcs:TaxonRelationshipAssertion ;
    rdf:subject <https://avibase.ca/82745BAA> ;
    rdf:predicate tcs:includes ;
    rdf:object <https://avibase.ca/A091D50A> ;
    dcterms:creator <https://orcid.org/0000-0003-2224-6821> ;
    dcterms:created "2023-07-31" .

[] a tcs:TaxonRelationshipAssertion ;
    rdf:subject <https://avibase.ca/F558C7F9> ;
    rdf:predicate tcs:isDisjointWith ;
    rdf:object <https://avibase.ca/A091D50A> ;
    dcterms:creator <https://orcid.org/0000-0003-2224-6821> ;
    dcterms:created "2023-07-31" .

[baskaufs]

Just to follow up on what @nielsklazenga said, Darwin Core basically uses the reification model in the dwc:ResourceRelationship class. When we wrote the DwC RDF Guide, we deferred on how to represent those terms in RDF and as I suggested in that talk Niels mentioned, using the RDF subject, predicate, and object reification properties would be a way to express resource relationships without minting new DwC dwciri: properties that mean the same thing.

If Darwin Core were to adopt what I proposed, then following the approach that Niels suggests in TCS2 would result in consistent modeling across TDWG, which makes more sense to me than to develop yet another system that does the same thing as the ReasourceRelationship terms and the RDF reification vocabulary.

I get what @camwebb said about reification not often being used as a core technology. But for better or worse, TCS2 is basically being defined using RDF, so using terms from the core RDF vocabulary to define the relationships makes sense to me and should be understandable by people outside of our community. That would not stop anyone in their own graph database from collapsing down the relationships as direct edges with properties, since Niels is proposing minting properties for the relationships (tcs:includes, tcs:isDisjointWith, etc.).

[ghwhitbread]

@nielsklazenga , let's try and avoid reification wherever possible (blank nodes too).

My preference is to continue with an extensible, generic Relationship class, sub-typed as necessary, that can be bundled or used stand-alone without reification.

A bodgied (ChatGPT) example for illustration, no attempt to be TCS or RDF compliant.

#### Define classes

tcs:TaxonConcept rdf:type rdfs:Class ;
    rdfs:label "Taxon Concept" .

#### Generic Relationship Class

tcs:Relationship rdf:type rdfs:Class ;
    rdfs:label "Generic Relationship" .

tcs:CongruentRelationship rdf:type rdfs:Class ;
    rdfs:subClassOf tcs:Relationship .

tcs:IncludedInRelationship rdf:type rdfs:Class ;
    rdfs:subClassOf tcs:Relationship .

tcs:RelationshipMetadata rdf:type rdfs:Class ;
    rdfs:label "Relationship Metadata" .

#### sub-typing hasRelationship if desired

tcs:hasCongruentRelationship rdf:type rdf:Property ;
    rdfs:subPropertyOf tcs:hasRelationship ;
    rdfs:domain tcs:TaxonConcept ;
    rdfs:range tcs:CongruentRelationship .


# Taxon Concepts and Relationships

<https://example.org/taxon-concept-1> a tcs:TaxonConcept ;
    dcterms:title "Campylium sec. Koperski et al. 2000" ;
    tcs:accordingTo <https://tropicos.org/reference/9022656> ;
    tcs:acceptedName <https://tropicos.org/name/35000208> ;
    tcs:hasCongruentRelationship [
        a tcs:CongruentRelationship ;
        tcs:object <https://example.org/related-taxon-concept-1> ;
        tcs:relationshipMetadata [
            a tcs:RelationshipMetadata ;
            rdfs:label "Congruence Relationship Metadata 1" ;
            dcterms:description "Metadata for the congruence relationship." ;
            # ... other metadata properties ...
        ]
    ] ;
    tcs:hasRelationship [
        a tcs:IncludedInRelationship ;
        tcs:object <https://example.org/related-taxon-concept-2> ;
        tcs:relationshipMetadata [
            a tcs:RelationshipMetadata ;
            rdfs:label "Included In Relationship Metadata 1" ;
            dcterms:description "Metadata for the included-in relationship." ;
            # ... other metadata properties ...
        ]
    ] ;
    # ... other properties ...

<https://example.org/related-taxon-concept-1> a tcs:TaxonConcept ;
    dcterms:title "Campylium sec. Corley et al. 1981" ;
    tcs:accordingTo <https://tropicos.org/reference/9004554> ;
    tcs:acceptedName <https://tropicos.org/name/35000208> ;
    # ... other properties ...

<https://example.org/related-taxon-concept-2> a tcs:TaxonConcept ;
    dcterms:title "Campylium sec. Smith 1980" ;
    tcs:accordingTo <https://tropicos.org/reference/9007023> ;
    tcs:acceptedName <https://tropicos.org/name/35000208> ;
    # ... other properties ...

<https://example.org/taxon-concept-3> a tcs:TaxonConcept ;
    dcterms:title "Chrysohypnum sec. Moenkemeyer 1927" ;
    tcs:accordingTo <https://tropicos.org/reference/9021085> ;
    tcs:acceptedName <https://tropicos.org/name/35000256> ;
    # ... other properties ...

<https://example.org/taxon-concept-4> a tcs:TaxonConcept ;
    dcterms:title "Drepanocladus sec. Moenkemeyer 1927" ;
    tcs:accordingTo <https://tropicos.org/reference/9021085> ;
    tcs:acceptedName <https://tropicos.org/name/35000413> ;
    # ... other properties ...

#### Relationship Statements

<https://example.org/relationship-statement-1> a tcs:Relationship ;
    tcs:subject <https://example.org/taxon-concept-1> ;
    tcs:predicate tcs:includes ;
    tcs:object <https://example.org/taxon-concept-2> ;
    dcterms:source <https://tropicos.org/reference/9022656> ;
    rdfs:comment """excl. *C. longicuspis (Lindb. & Arnell) Hedenäs (syn. 
            *Amblystegium l. Lindb. & Arnell, *Drepanocladus l. (Lindb. & 
            Arnell) Broth., Pseudocalliergon l. (Lindb. & Arnell) Loeske), da 
            Hedenäs diese Kombination erst 1989 schuf. Es bleibt unklar zu 
            welcher Gattung SMITH dieses auf den Britischen Inseln nicht 
            nachgewiesene Taxon stellt""" .

[nielsklazenga]

Note that my proposal (or @camwebb's proposal as adulterated by me) does not introduce reification to TCS or adds more reification to TCS. Whenever there is a relationship object, there is reification, no matter what namespace the properties are in. In fact this proposal reduces the amount of reification (and my original proposal removed it altogether) by not hard-coding it into TCS, but leaving it to the data and/or the implementation whether reification is needed.

The proposal also does not add any new terms to TCS. In fact, it reduces the number of terms defined in TCS by borrowing syntax terms from other specifications that are specifically designed for that.

A "generic Relationship class" is already in Darwin Core in the form of the dwc:ResourceRelationship, so would not be part of TCS. This was my original proposal. I do not think there is such a thing as a relationship object without reification.

So, the only question (regarding relationship classes) in the purview of the TCS 2 Task Group is whether or not we keep the TaxonRelationshipAssertion class (ignoring the issue of the name of the class for now). As TaxonRelationshipAssertion is a top-level element in TCS 1 and since we have translated those top-level elements to classes in TCS 2, there needs to be unanimous consent to remove it, so I think we have no choice but to keep it, although I personally think this sort of stuff does not belong in a Standard but in an Application Profile.

We can discuss whether we define the properties of the TaxonRelationshipAssertion class in TCS (like we're doing now) or borrow them from RDF and Dublin Core, but this is also not entirely up to us, as the final decision is not ours and I think people generally will prefer a TDWG wide solution rather than have different standards do different things. I think we should do whatever gives us the highest chance of ratification, so all our work has not been for nothing.