• Last verification: 20220909
• Tools required for this lab:
  • Protégé Desktop 5

• Introduction to SHACL.pdf

1. Run the Protégé Desktop.
2. Open File → Check for plugins…
3. Select tickbox on the left side of two plugins (if they are not listed, they are already installed in the newest version):
   1. SWRLTab Protege 5.0+ Plugin
   2. SHACL4Protege Constraint Validator
4. Click Install
5. After a while, you will see message: “Updates will take effect when you next start Protege.”
6. Close Protégé and run it again (to load the new plugins).

• The OWL 2 language (known from previous labs on ontologies and reasoning) is not able to express all relations. E.g., it cannot express the relation child of married parents, because there is no way in OWL 2 to express the relation between individuals with which an individual has relations:
  
  To address this gap, and to allow this and other kind of inferences, the Semantic Web Rule Language (SWRL) was introduced:

  Person(?x) ^ hasParent(?x, ?y) ^ hasParent(?x, ?z) ^ hasSpouse(?y, ?z) -> ChildOfMarriedParents(?x)

  Also, sometimes you can describe something using OWL, but it can be more intuitive when defined as a SWRL rule.

• As you can see, rules in SWRL has a simple structure:
  • There is a left-hand side (called the antecedent) and a right-hand side (called the consequent). They are separated by an arrow (->).
  • Each expression in a SWRL rule is separated by a ^ sign (logical and).
  • All parameters (variables that are wildcards and get bound dynamically as the rule fires) are preceded by a ?.
  • There are three types of expressions in SWRL:
    • Class expressions. This is the name of a class followed by parentheses with a parameter inside, e.g., Person(?x) will bind ?x to an instance of the class Person and will iterate over each instance of the Person class.
    • Property expressions. This is the name of a property followed by parentheses and two parameters: the first is the subject, and the second is the object of a relation, e.g., hasParent(?x, ?y) will bind ?y to each parent of ?x (note that the ?x will be bound in the previous expression).
    • Built-in functions. SWRL has a number of built-in functions for doing mathematical tests, string tests, etc. All of them are prefaced by the swrlb: prefix, e.g., the math built-in swrlb:greaterThan(?age, 18) succeeds if the value of ?age is greater than 18. See 8. Built-Ins for full list and documentation.
• The consequent of the rule fires if and only if every expression in the antecedent is satisfied.
• The Protégé supports SWRL
  • They are parsed and interpreted by both HermiT and Pellet reasoners
  • There are two dedicated interfaces to view and edit SWRL rules (there are slight differences between them, e.g., ^ are changed to commans in the Rule view):
    • The SWRLTab: if it is not visible, select Window → Tabs → SWRLTab (there is no need to use the Drools engine in the bottom panel; we will use the HermiT/Pellet reasoners)
    • The Rule view: select Window → Views → Ontology views → Rules and click somewhere in the Protege, where this view should be placed.

1. Download the family.swrl.owl ontology (mirror: family.swrl.owl) and load it into Protege.
2. Take a look at the existing classes, properties, and instances (in the Entities tab).
3. Open one of the dedicated interfaces for the SWRL (as described above).
4. Take a look at the SWRL rules. Do you understand them?
5. Run the rules:
   1. Under Reasoner menu select HermiT or Pellet reasoner
   2. Reasoner → Start Reasoner (or Synchronize reasoner if it was started before)
6. Take a look at inferred knowledge

1. Open your own ontology in the Protege Desktop.
2. Prepare 3-5 rules for your ontology.
3. Run them to check if they work correctly.
4. After adding rules, don't forget to save the new version of the ontology so you don't lose your work if something will go wrong!

1. Open the Shapes Constraint Language (SHACL). It may be useful as a reference.
2. Protégé has dedicated plugin for SHACL. We will try it now (it should be already installed as the first task during this lab).
   If you do not like the Protégé plugin, you can also work at:
   • Zazuko SHACL Playground
   • SHACL validate data at RDFShape
3. Download the example OWL file (mirror) and load it into Protege (simply File → Open…)
4. Open dedicated tab by selecting: Window → Tabs → SHACL Editor.
5. By default, it will show sample SHACL graph with ex:PersonShape. If it is not there, simply copy the following file to SHACL Editor:

   @prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
   @prefix sh:    <http://www.w3.org/ns/shacl#> .
   @prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
   @prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
   @prefix ex:    <http://www.example.org/#> .
   @prefix owl:   <http://www.w3.org/2002/07/owl#> .
    
   ex:PersonShape
       a sh:NodeShape ;
       sh:targetClass ex:Person ; # Applies to all persons
       sh:property [              # _:b0
           sh:path ex:ssn ;       # constrains the values of ex:ssn
           sh:maxCount 1 ;
       ] ;
       sh:property [              # _:b1
           sh:path ex:ssn ;       # constrains the values of ex:ssn
           sh:datatype xsd:string ;
           sh:pattern "^\\d{3}-\\d{2}-\\d{4}$" ;
           sh:severity sh:Warning ;
       ] ;
       sh:closed true ;
       sh:ignoredProperties ( rdf:type owl:topDataProperty owl:topObjectProperty ) ;
       .

6. Click Validate to see the Validation Report (in the table, at the bottom).
   You can also start reasoner before running the validation → then the shapes will be also validated against inferred knowledge.
   There is also a possibility to filter the report by classes and instances (simply click on the class/instance in the left panel of the SHACL Editor tab).
7. There are new type of constraints named sh:pattern and sh:closed (combined with sh:ignoredProperties). Do you understand them?
   For a list of available (core) constraints, see the table below and the 4. Core Constraint Components section of SHACL recommendation.
   
8. There are 6 violations. Fix them! (fix the knowledge base and/or change the constraints)

1. Open your own ontology (with SWRL rules developed during this lab) in the Protégé.
2. Prepare some SHACL shapes for your ontology (at least 2 PropertyShapes).
3. Validate the knowledge base and observe the Validation Report to check if they work correctly.
4. Save the SHACL shapes in a separate file (they are not saved with the ontology; you need to save them using Save button in the SHACL Editor tab; the file should have .ttl extension, as it is a regular Turtle file)

These instructions are based on New Protégé Pizza Tutorial, OWL 2 and SWRL Tutorial and Shapes applications and tools tutorial

SWRL:

• Standard:
  • W3C Submission: SWRL: A Semantic Web Rule Language Combining OWL and RuleML
• Tutorials:
  • New Protégé Pizza Tutorial (2021)
  • SWRL Process Modeling Tutorial (2020)
  • OWL 2 and SWRL Tutorial (2012)
  • Excellent slides about SWRL: SWRL2009ProtegeConference.pdf
• Tools:
  • SWRLAPI – API for Java; used as a base for Protege plugin

SHACL:

• Standard:
  • Shapes Constraint Language (SHACL)
  • SHACL Advanced Features (e.g., SHACL Functions and SHACL Rules)
• Readings:
  • Validating RDF Data (2018) – free HTML book on SHACL (and ShEx)
  • SHACL and OWL Compared
• Tutorials:
  • Tutorials at ValidatingRDF
  • Introduction to SHACL.pdf
• Tools:
  • SHACL Playground
  • SHACL Validator at RDFShape
  • SHACL4Protege
  • List of open source tools is provided, e.g., at Wikipedia
• ShEx (Shape Expressions) – although similar to SHACL and with a similar purpose (specifying the structure of RDF graphs), it is an independent language:
  • SHACL defines constraints for specific classes (and validates them), while ShEx defines the schema (and tries to best match the definitions with instances)
  • Standard: Shape Expressions Language
  • A chapter in Validating RDF Data: Chapter 7. Comparing ShEx and SHACL