Knowledge Graph Modeling: Group micro-pattern using gist

July 1, 2020 | 3 minute read
Michael J. Sullivan
Principal Cloud Solutions Architect
Text Size 100%:

This is the third in a series of blogs describing how one would go about modeling an enterprise 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: into an ontology editor such as Protege (see:, 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:


@prefix ex1:  <> .
@prefix ex:   <> .
@prefix gist: <> .
@prefix rdfs: <> .

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 .

#  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!




Michael J. Sullivan

Principal Cloud Solutions Architect

Previous Post

Cisco CSR1000v High Availability (HA) Deployment in OCI

Javier Ramirez | 23 min read

Next Post

Invoke REST Endpoint With Plain Text Payload

Greg Mally | 4 min read