Home » Inferencing » Rules
Category Archives: Rules
Creating Custom Rule Primitives for Jena
In this post I will show you
- how to add your own custom rule primitive,
- how to inform Jena of your custom rule primitive, and
- I will discuss things you have to keep in mind when writing a custom
primitive.
Adding a Custom Rule Primitive
A powerful feature of Jena is that it allows you to create your own custom builtin rule primitives. Building on our student example of the previous post, assume we want to calculate the final mark for a student given their test result, exam result and project result. We assume we have the following data
:Peet :hasTestResult 77 . :Peet :hasExamResult 86 . :Peet :hasProjectResult 91 .
for which we add the following rule
[calcStudentFinalMarkRule: (?student :hasTestResult ?testResult) (?student :hasExamResult ?examResult) (?student :hasProjectResult ?projectResult) calcFinalMark(?testResult, ?examResult, ?projectResult, ?finalMark) -> (?student :hasFinalMark ?finalMark)]
The meat of the implementation is the doUserRequiredAction(args, length,
method, which consists of the following steps:
context)
- check that we have the correct number of parameters,
- retrieve the input parameters,
- verify the typing of input parameters,
- doing the actual calculation,
- creating a node for the output parameter, and
- binding the node to the output parameter.
private boolean doUserRequiredAction(Node[] args, int length, RuleContext context) { // Check we received the correct number of parameters checkArgs(length, context); boolean success = false; // Retrieve the input arguments Node studentTestResult = getArg(0, args, context); Node studentExamResult = getArg(1, args, context); Node studentProjectResult = getArg(2, args, context); // Verify the typing of the parameters if (studentTestResult.isLiteral() && studentExamResult.isLiteral() && studentProjectResult.isLiteral()) { Node finalMark = null; if (studentTestResult.getLiteralValue() instanceof Number && studentExamResult.getLiteralValue() instanceof Number && studentProjectResult.getIndexingValue() instanceof Number) { Number nvStudentTestResult = (Number)studentTestResult.getLiteralValue(); Number nvStudentExamResult = (Number)studentExamResult.getLiteralValue(); Number nvStudentProjectResult = (Number)studentProjectResult.getLiteralValue(); // Doing the calculation int nFinalMark = (nvStudentTestResult.intValue() * 20)/100 + (nvStudentExamResult.intValue() * 50)/100 + (nvStudentProjectResult.intValue() * 30)/100; // Creating a node for the output parameter finalMark = Util.makeIntNode(nFinalMark); // Binding the output parameter to the node BindingEnvironment env = context.getEnv(); success = env.bind(args[3], finalMark); } } return success; }
Registering a Custom Primitive with Jena
Our code for load our rules and activating it is similar to my previous post, except that you have to make a call to register the custom primitive:
// Load RDF data String data = path.toFile().getAbsolutePath() + "/src/main/resources/data2.ttl"; Model model = ModelFactory.createDefaultModel(); model.read(data); // Register custom primitive BuiltinRegistry.theRegistry.register(new CalcFinalMark()); // Load rules String rules = path.toFile().getAbsolutePath() + "/src/main/resources/student2.rules"; Reasoner reasoner = new GenericRuleReasoner(Rule.rulesFromURL(rules)); InfModel infModel = ModelFactory.createInfModel(reasoner, model); infModel.rebind();
Things to Keep in Mind
There are two main things I think one needs to keep in mind with Jena custom rule primitives:
- A primitive is suppose to be a elementary building block. Being able to create your own primitives may tempt you to add all sorts of interesting processing besides the manipulation of triples, but I strongly advice against that. Arbitrary processing in your builtin primitive can degrade performance of inferencing.
- Do not assume that you have control over when a rule will be triggered. Exactly when a rule will be triggered is dependent on when the Jena
InfModel
implementation decides to re-evaluate the rules, which is dependent on internal caching of the InfModel implementation and how it deals with modifications made to the model. Even though I believeInfModel
implementations will avoid arbitrarily re-evaluating rules, I still think it is conceivable that under some circumstance the same rule may be triggered more than once for the same data. Furthermore, the Jena documentation of 3.6.0 states that theInfModel
interface is still in flux, which could mean that even if a rule is only triggered once for given data currently, due to unforeseen changes it may be triggered more than once in future updates of Jena.
Conclusion
In this post I gave an example of how you can develop a custom rule primitive for Jena. The code for this example can be found at github.
Creating Custom Rules for Jena
In this post I will show you
- how to add your own custom rules to Jena,
- how to use rule primitives, and
- I will mention some things you may want to keep in mind when using rules.
Add and Activate Rules
We assume we start with the following simple triples:
:Peet :takesCourse :ComputerScience . :Ruth :teachesCourse :ComputerScience .
for which we add the following rule to a student1.rules
file:
[hasStudentRule: (?student :takesCourse ?course) (?lecturer :teachesCourse ?course) -> (?lecturer :hasStudent ?student)]
The hasStudentRule
says that if a student takes a course and that course is presented by some lecturer, then the student is a student of that lecturer. The (?student :takesCourse ?course) (?lecturer :teachesCourse ?course)
part of the rule is referred to as the premise or body of the rule and the (?lecturer :hasStudent ?student)
part as the conclusion or head of the rule.
To activate the rules in Jena we have to create a model that is capable of doing inferences. In the context of Jena inferencing means that it will re-evaluate the rules against the data, which will cause additional statements to be potentially added to the model. This can be achieved by calling methods that will cause Jena to re-evaluate the model, i.e. calls like InfModel.rebind()
and InfModel.validate()
.
Path path = Paths.get(".").toAbsolutePath().normalize(); // Load RDF data String data = path.toFile().getAbsolutePath() + "/src/main/resources/data.ttl"; Model model = ModelFactory.createDefaultModel(); model.read(data); // Load rules String rules = path.toFile().getAbsolutePath() + "/src/main/resources/student.rules"; Reasoner reasoner = new GenericRuleReasoner(Rule.rulesFromURL(rules)); InfModel infModel = ModelFactory.createInfModel(reasoner, model); infModel.rebind();
When the hasStudentRule
is activated a new statement will be added to the Jena model:
:Ruth :hasStudent :Peet .
Using Rule Primitives
Jena supports a number of builtin rule primitives that are intuitive to understand, i.e.
[pensionerRule: (?person :hasAge ?age) greaterThan(?age, 60) -> (?person a :Pensioner)]
which states that when ?person
has an age greater than 60, ?person
is considered to be a pensioner. Assuming we have the data
:Peet :hasAge 90 .
the following triple will be added to the Jena model:
:Peet a :Pensioner .
Things to Keep in Mind
There are two main things I think one needs to keep in mind with Jena rules:
- The purpose of rules are to manipulate the triples in the Jena model. For the most part it adds triples to the model, but it can also remove triples from the model if primitives like
remove
anddrop
are used. - Adding and removing of triples can be achieved through SPARQL queries which can perform better or worse than rules. It is therefore best to check both approaches for your given use case.
Conclusion
In this post I gave a brief introduction in how to use custom rules and builtin rule primitives in Jena. This code is available at github.
Classification with SHACL Rules
In my previous post, Rule Execution with SHACL, we have looked at how SHACL rules can be utilized to make inferences. In this post we consider a more complex situation where SHACL rules are used to classify baked goods as vegan friendly or gluten free based on their ingredients.
Why use SHACL and not RDF/RDFS/OWL?
In my discussion I will only concentrate on the definition of vegan friendly baked goods since the translation to gluten free baked goods is similar. Gluten free baked goods are included to give a more representative example.
Essentially what we need to do is look at a baked good and determine whether it includes non-vegan friendly ingredients. If it includes no non-vegan friendly ingredients, we want to assume that it is a vegan friendly baked good. This kind of reasoning uses what is called closed world reasoning, i.e. when a fact does not follow from the data, it is assumed to be false. SHACL uses closed world reasoning and hence the reason for why it is a good fit for this problem.
RDF/RDFS/OWL uses open world reasoning, which means when a fact does not follow from data or schema, it cannot derive that the fact is necessarily false. Rather, it is both possible (1) that the fact holds but it is not captured in data (or schema), or (2) the fact does not hold. For this reason RDF/RDFS/OWL will only infer that a fact holds (or does not hold) if it explicitly stated in the data or can be derived from a combination of data and schema information. Hence, for this reason RDF/RDFS/OWL are not a good fit for this problem.
Baked Goods Data
Below are example baked goods RDF data:

Bakery RDF data
A couple of points are important w.r.t. the RDF data:
- Note that we define both
VeganFriendly
andNonVeganFriendly
ingredients to be able to identify ingredients completely. Importantly we state thatVeganFriendly
andNonVeganFriendly
are disjoint so that we cannot inadvertently state that an ingredient is bothVeganFriendly
andNonVeganFriendly
. - We state that
AppleTartA
–AppleTartD
are of typeBakedGood
so that when we specify our rules, we can state that the rules are applicable only to instances of typeBakedGood
. - We enforce the domain and range for
bakery:hasIngredient
which results in whenever we saybakery:a bakery:hasIngredient bakery:b
, the reasoner can infer thatbakery:a
is of typebakery:BakedGood
andbakery:b
is of typebakery:Ingredient
.
Baked Good Rules
Now we define the shape of a baked good:

BakedGood shape
We state that bakery:BakedGood a rdfs:Class
which is important to be able to apply rules to instances of bakery:BakedGood
. We also state that bakery:BakedGood a sh:NodeShape
which allows us to add shape and rule information to bakery:BakedGood
. Note that our bakery:BakedGood
shape state that a baked good has at least one property called bakery:hasIngredient
with range bakery:Ingredient
.
We now add a bakery:NonVeganFriendly
shape

NonVeganFriendly shape
which we will use in the rule definition of bakery:BakedGood
:

VeganBakedGood and NonVeganBakedGood rules
We add two rules, one for identifying a bakery:VeganBakedGood
and one for a bakery:NonVeganBakedGood
. Note that these rules are of type sh:TripleRule
, which will infer the existence of a new triple if the rule is triggered. The first rule states that the subject of this triple is sh:this, which refers to instances of our bakery:BakedGood
class. The predicate is rdf:type
and the object is bakery:VeganBakedGood
. So if this rule is triggered it will infer that an instance of bakery:BakedGood
is also an instance of type bakery:VeganBakedGood
.
Both rules have two conditions which instances must adhere to before these rules will trigger. These rules will only apply to instances of bakery:BakedGood
according to the first condition. The second condition of the rule for bakery:VeganBakedGood
checks for bakery:hasIngredient
properties of the shape bakery:NonVeganFriendly
. This ensures that the range of bakery:hasIngredient
is of type bakery:NonVeganFriendly
. If bakery:hasIngredient
has a maximum count of 0, it will infer that this instance of bakery:BakedGood
is of type bakery:VeganBakedGood
. The rule for bakery:NonVeganBakedGood
will also check for bakery:hasIngredient
properties of the shape bakery:NonVeganFriendly
, but with minimum count of 1 for which it will then infer that this instance is of type bakery:NonVeganBakedGood
.
Jena SHACL Rule Execution Code
The Jena SHACL implementation provides command line scripts (/bin/shaclinfer.sh
or /bin/shaclinfer.bat
) which takes as arguments a data file and a shape file which can be used to do rule execution. However, for this specific example you have to write your own Java code. The reason being that the scripts creates a default model that has no reasoning support. In this section I provide the SHACL Jena code needed to do the classification of baked goods.

Shacl rule execution
Running the Code
Running the code will cause an inferences.ttl
file to be written out to
$Project/src/main/resources/
. It contains the following output:

Classification of baked goods
Conclusion
In this post I gave a brief overview of how SHACL can be used to do classification based on some property. This code example is available at shacl tutorial. This post was inspired by a question on Stack Overflow.
If you have any questions regarding SHACL or the semantic web, please leave a comment and I will try to help where I can.