This is the third in a series of blogs describing how one would go about modeling an upper-level ontology.
Gist is a minimalist upper-level ontology that can help you bootstrap the implementation of your Knowledge Graph ontologies/taxonomies. In the previous blog, I introduced the concept of simple buckets using gist. In this blog we kick it up a notch and introduce a slightly more advanced bucket concept that is built into gist: that of "Groups". If we load the gist core ontology (see: https://github.com/semanticarts/gist) into an ontology editor such as Protege (see: https://protege.stanford.edu/), we see this explanation of what a Group means:
"Group: A collection of People. The group may or may not be an Organization. Many organizations consist of groups of people, but that is not a defining characteristic."
You will also notice that Group is a type of Collection. As such it inherits the properties of Collection as well. (see Protege screen shot below).
Given the above definitions, we can now implement a reusable Group micro-pattern which can be used for creating and managing any group of people going forward. One key thing to notice is that a Group is basically a Collection of Persons. Which means that our group members will need to be of type gist:Person (as in the previous blog). Only here, we aren't using person as a "bucket" to organize things but rather we use it to formalize the contents of our Group bucket. Also notice that in this case the "meaning" of a Group is that it is defined by its members being referred to via the gist:hasMember object property. This doesn't mean that your application can't have the member choose the group using gist:memberOf predicate, au contraire: notice that gist:memberOf and gist:hasMember are inverse predicates. Thus, using either will infer the other, thus satisfying the meaning of what it means to be a Group in gist.
Here's what the micro-pattern looks like:
THE ABOVE IN TURTLE FORMAT:
@prefix ex1: <https://data.example.com/> . @prefix ex: <https://taxa.example.com/> . @prefix gist: <https://semantic-arts.com/gist/> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . gist:Group rdfs:subClassOf gist:Collection ex:MyTeam a gist:Group ex:MyTeam gist:hasMember ex1:Dolf . ex:MyTeam gist:hasMember ex1:Emma . ex:MyTeam gist:hasMember ex1:Paddy . ex1:Dolf a gist:Person . ex1:Emma a gist:Person . ex1:Paddy a gist:Person . # INFERRED: # ex1:Dolf gist:memberOf ex:MyTeam . # ex1:Emma gist:memberOf ex:MyTeam . # ex1:Paddy gist:memberOf ex:MyTeam .
Isn't that simple? Not only are groups easy and flexible to implement in RDF (using gist) but coding for searching/rendering them will be nearly identical for any type of group! And because of inferencing, you can search for which groups a person belongs to as easily as which persons are members of a group — sweet!