What is the principle of sh:order in shacl rule? - shacl

Question

Even though my actual data and shape graph is completely different, I want to understand the general idea of sh:order in shacl. Therefore I took examples from the official documentation. I assume that my data graph looks like this:
#prefix ex: <http://example.org/ns#> .
ex:Bob
a ex:Person ;
ex:sibling ex:John .
ex:Alice
a ex:Person ;
ex:parent ex:Bob .
ex:John
a ex:Person ;
ex:sibling ex:Bob .
ex:Jane
a ex:Person ;
ex:parent ex:John .
And the shacl rules:
#prefix ex: <http://example.org/ns#> .
#prefix sh: <http://www.w3.org/ns/shacl#> .
#prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
ex:
sh:declare [ sh:prefix "ex" ;
sh:namespace "http://example.org/ns#" ; ] .
ex:FamilyShape
a sh:NodeShape ;
sh:targetClass ex:Person ;
sh:rule [ a sh:SPARQLRule ;
rdfs:label "Infer uncles, i.e. male siblings of the parents of $this" ;
sh:prefixes ex: ;
sh:order 1 ;
sh:construct """
CONSTRUCT {
?p a ex:Person .
?p ex:parent ?f .
?f ex:sibling ?s .
?p ex:uncle ?s .
}
WHERE {
?p a ex:Person .
?p ex:parent ?f .
?f ex:sibling ?s .
}
""" ; ] ;
sh:rule [ a sh:SPARQLRule ;
rdfs:label "Infer cousins, i.e. the children of the uncles" ;
sh:prefixes ex: ;
sh:order 2 ;
sh:construct """
CONSTRUCT {
?p a ex:Person .
?p ex:parent ?f .
?f ex:sibling ?s .
?p ex:uncle ?uncle .
?p ex:cousin ?cousin .
}
WHERE {
?p a ex:Person .
?p ex:parent ?f .
?f ex:sibling ?s .
?p ex:uncle ?uncle .
?cousin ex:parent ?uncle .
}
""" ; ] .
What I want is firstly, to create ex:uncle prediction and secondly, relying on this result creating ex:cousin predicate. Until here everything works perfectly, as far as I set sh:order correctly. Unexpected result happens when I change the logic of rules.
For example, in the next shape firstly, I filter out (I aim to delete a specific node) a node, secondly apply second rule.
#prefix ex: <http://example.org/ns#> .
#prefix sh: <http://www.w3.org/ns/shacl#> .
#prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
ex:
sh:declare [ sh:prefix "ex" ;
sh:namespace "http://example.org/ns#" ; ] .
ex:FamilyShape
a sh:NodeShape ;
sh:targetClass ex:Person ;
sh:rule [ a sh:SPARQLRule ;
sh:prefixes ex: ;
sh:order 1 ;
sh:construct """
CONSTRUCT {
?p a ex:Person .
?p ex:parent ?f .
}
WHERE {
?p a ex:Person .
OPTIONAL {
?p ex:parent ?f .
OPTIONAL {
?f ex:sibling ?s .
FILTER NOT EXISTS { ?f ex:sibling ?s }
}
}
}
""" ; ] ;
sh:rule [ a sh:SPARQLRule ;
sh:prefixes ex: ;
sh:order 2 ;
sh:construct """
CONSTRUCT {
?p a ex:Person .
?p ex:parent ?f .
?p ex:uncle ?s .
}
WHERE {
?p a ex:Person .
?p ex:parent ?f .
?f ex:sibling ?s .
}
""" ; ] .
More precisely, I want to create a ex:uncle predicate if there is ex:sibling predicate. I expect the result as below:
<ex:Bob>
a <ex:Person> .
<ex:Alice>
a <ex:Person> ;
<ex:parent> <ex:Bob> .
<ex:John>
a <ex:Person> .
<ex:Jane>
a <ex:Person> ;
<ex:parent> <ex:John> .
However, the actual output is different.
<ex:Bob>
a <ex:Person> ;
<ex:sibling> <ex:John> .
<ex:Alice>
a <ex:Person> ;
<ex:parent> <ex:Bob> ;
<ex:uncle> <ex:John> .
<ex:John>
a <ex:Person> ;
<ex:sibling> <ex:Bob> .
<ex:Jane>
a <ex:Person> ;
<ex:parent> <ex:John> ;
<ex:uncle> <ex:Bob> .
I am using topbraid's shacl library (version 1.3.2).
Here I assume that the shacl takes always initial data in each rule (step) but considering only extension to it. What I expect is each of next rule (ordered by sh:order) takes the result of previous execution.
I read the official documentation, but it does not say anything about it.