Eliminate SPARQL in valueRangePair

[VladimirAlexiev]

Described in https://github.com/Sveino/Inst4CIM-KG/tree/develop/shacl-improved#use-shequals-instead-of-sparql

ls -1 *valueRangePair*
GeneratingUnit.nominalP-valueRangePair.rq
PhaseTapChangerLinear.xMin-valueRangePair.rq
PhaseTapChangerNonLinear.xMin-valueRangePair.rq
TapChanger.neutralU-valueRangePair.rq

Eg GeneratingUnit.nominalP-valueRangePair.rq has this purpose

The attribute shall be a positive value equal to or less than RotatingMachine.ratedS.

So you need to use:

sh:minExclusive 0;
sh:lessThanOrEqual cim:RotatingMachine.ratedS.

[nataschake]

@VladimirAlexiev
In these three shapes, defining GeneratingUnit.nominalP-valueRangePair

equ:GeneratingUnit.nominalP  a  sh:NodeShape ;
        sh:property     equ:GeneratingUnit.nominalP-valueRangePair ;
        sh:targetClass  cim:GeneratingUnit , cim:WindGeneratingUnit , cim:HydroGeneratingUnit , cim:NuclearGeneratingUnit , cim:SolarGeneratingUnit , cim:ThermalGeneratingUnit .
              
equ:GeneratingUnit.nominalP-valueRangePair
        a               sh:PropertyShape ;
        sh:sparql       equ:GeneratingUnit.nominalP-valueRangePairSparql ;
        sh:description  "The attribute shall be a positive value equal to or less than RotatingMachine.ratedS." ;
        sh:name         "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:path         cim:GeneratingUnit.nominalP ;
        sh:group        equ:EQ301UML ;
        sh:order        71 ;
        sh:severity     sh:Violation .
            
equ:GeneratingUnit.nominalP-valueRangePairSparql
    a         sh:SPARQLConstraint ;  
    sh:message "The value is either negative, zero or greater than RotatingMachine.ratedS." ;
    sh:prefixes cim: ;
    sh:select """
      SELECT  $this ?value
      WHERE {
        $this $PATH ?value .
        BIND(EXISTS{$this $PATH ?v} AS ?hasvalue).
        #OPTIONAL {$this $PATH ?value }. 
        $this ^cim:RotatingMachine.GeneratingUnit/cim:RotatingMachine.ratedS ?rateds .
        BIND(EXISTS{$this ^cim:RotatingMachine.GeneratingUnit/cim:RotatingMachine.ratedS ?r} AS ?hasrateds).
        #OPTIONAL {$this ^cim:RotatingMachine.GeneratingUnit ?machine }. 
        #OPTIONAL {?machine cim:RotatingMachine.ratedS ?rateds }. 
        FILTER (?hasvalue=true && ?hasrateds=true && (?value<=0 || ?value>?rateds) ) .        
      }""" . 

using

sh:minExclusive 0 ;
sh:lessThanOrEqual cim:RotatingMachine.ratedS .

instead of SPARQL does not seem correct.

As you see, in the SPARQLConstraint there are inverse path and property path

$this ^cim:RotatingMachine.GeneratingUnit/cim:RotatingMachine.ratedS ?rateds .

that goes to another node (RotatingMachine), that has a property ratedS, but sh:lessThanOrEqual can be applied only to the same focus node.
So I would change to

equ:GeneratingUnit.nominalP-valueRangePair
        a               sh:PropertyShape ;
        sh:description  "The attribute shall be a positive value equal to or less than RotatingMachine.ratedS." ;
        sh:message      "The value is either negative, zero or greater than RotatingMachine.ratedS." ;
        sh:name         "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:path         cim:GeneratingUnit.nominalP ;
        sh:minExclusive 0 ;
        sh:lessThanOrEquals ([sh:inversePath cim:RotatingMachine.GeneratingUnit] cim:RotatingMachine.ratedS) ;
        sh:group        equ:EQ301UML ;
        sh:order        71 ;
        sh:severity     sh:Violation . 

From the other hand,
there is a comment in a thread on property paths in sh:equals and 3 more, saying that it is allowed in SHACL 1.2, also here is SHACL 1.2 fresh spec part on this.
So, the result of this check will depend on the validation engine

        sh:lessThanOrEquals ([sh:inversePath cim:RotatingMachine.GeneratingUnit] cim:RotatingMachine.ratedS) ;

and SHACL 1.0 engine rejects it.

ShaclShapeParsingException: Expected predicate <http://www.w3.org/ns/shacl#lessThanOrEquals> to have an IRI as object, but found BNode for _:201b1d62ff7775bd - Caused by shape with id: <http://iec.ch/TC57/ns/CIM/Equipment-EU/constraints/IEC61970-301/3.0#GeneratingUnit.nominalP-valueRangePair>

[nataschake]

...Or, once we can't use complex path with sh:lessThanOrEquals, let's define a property shape at the other end.

equ:RotatingMachine.ratedS-nominalPRangePair
    a               sh:PropertyShape ;
    sh:path         ( cim:RotatingMachine.GeneratingUnit cim:GeneratingUnit.nominalP ) ;
    sh:minExclusive 0 ;
    sh:lessThanOrEquals cim:RotatingMachine.ratedS ;
    sh:description  "GeneratingUnit.nominalP shall be a positive value equal to or less than RotatingMachine.ratedS." ;
    sh:message      "GeneratingUnit.nominalP is negative, zero, or greater than RotatingMachine.ratedS." ;
    sh:severity     sh:Violation .

equ:RotatingMachine.ratedS-nominalPRangePairShape
    a sh:NodeShape ;
    sh:targetClass cim:RotatingMachine ;   # or the concrete subclasses that have ratedS/GeneratingUnit
    sh:property equ:RotatingMachine.ratedS-nominalPRangePair .

Focus node is different: an instance of cim:RotatingMachine (the object that actually carries RotatingMachine.ratedS).

sh:path (cim:RotatingMachine.GeneratingUnit cim:GeneratingUnit.nominalP) is a sequence path,going from the RotatingMachine focus node, through its GeneratingUnit, to nominalP.
sh:path itself allows complex paths; only sh:lessThanOrEquals/sh:lessThan/sh:equals/sh:disjoint are restricted to a plain IRI in 1.0.
sh:lessThanOrEquals cim:RotatingMachine.ratedS now compares those value nodes (nominalP values reached via the path) against ratedS, which is a simple, direct property of the same focus node (RotatingMachine) , which is ok in SHACL 1.0.
sh:minExclusive 0 still validates positivity of the same value nodes.
This reproduces the same semantic check ("nominalP is positive and ≤ ratedS") without SPARQL and without violating the SHACL 1.0 restriction that sh:lessThanOrEquals (and its siblings) must reference a plain predicate evaluated at the focus node — only the roles of "focus node" and "which side is reached via a path" are swapped.

From the other hand, cim:RotatingMachine is abstract, and to get to instances there will be
one for

equ:SynchronousMachine
        a               sh:NodeShape ;
        sh:property     equ:RotatingMachine.ratedU-valueRange , equ:RotatingMachine.ratedS-valueRange , equ:RotatingMachine.ratedPowerFactor-valueRange , equ:RotatingMachine.ratedS-nominalPRangePair ;
        sh:targetClass  cim:SynchronousMachine .

one for

equ:AsynchronousMachine
        a               sh:NodeShape ;
        sh:property     equ:RotatingMachine.ratedU-valueRange , equ:RotatingMachine.ratedS-valueRange , equ:RotatingMachine.ratedPowerFactor-valueRange , equ:RotatingMachine.ratedS-nominalPRangePair ;
        sh:targetClass  cim:AsynchronousMachine .

and

equ:RotatingMachine.ratedS-nominalPRangePair
        a                    sh:PropertyShape ;
        sh:path              ( [ sh:inversePath cim:RotatingMachine.GeneratingUnit ] cim:GeneratingUnit.nominalP ) ;
        sh:minExclusive      "0.0"^^xsd:float ;
        sh:lessThanOrEquals  cim:RotatingMachine.ratedS ;
        sh:description       "The attribute shall be a positive value equal to or less than RotatingMachine.ratedS." ;
        sh:message           "The value is either negative, zero or greater than RotatingMachine.ratedS." ;
        sh:name              "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:group             equ:EQ301UML ;
        sh:order             71 ;
        sh:severity          sh:Violation .

and here we can't just use sh:name ...GeneratingUnit.nominalP:..., because this name will be not correct for RotatingMachine

[VladimirAlexiev]

@nataschake as discussed in call:

• Better to keep the original focusNode (not to introduce too large refactoring)
• Move the complex path in sh:path, and use an atomic predicate for sh:lessThan...`
• Use sh:not .. sh:lessThan to invert the arithmetic check (<= corresponds to not(<) with flipped values)
• Be aware that only relations with cims:AssociationUsed "Yes" exist in CIM instance data

[nataschake]

@VladimirAlexiev
for equ:GeneratingUnit.nominalP-valueRangePair defined in 61970-301_Equipment-AP-Con-Complex-SHACL.ttl, line L1234

equ:GeneratingUnit.nominalP  a  sh:NodeShape ;
        sh:property     equ:GeneratingUnit.nominalP-valueRange ;
        sh:not          [
                a               sh:PropertyShape ;
                sh:path         ( [ sh:inversePath cim:RotatingMachine.GeneratingUnit ] cim:RotatingMachine.ratedS ) ;
                sh:lessThan     cim:GeneratingUnit.nominalP ;
        ] ;
        sh:description  "The attribute shall be a positive value equal to or less than RotatingMachine.ratedS." ;
        sh:message      "The value is either negative, zero or greater than RotatingMachine.ratedS." ;
        sh:name         "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:group        equ:EQ301UML ;
        sh:order        71 ;
        sh:severity     sh:Violation ;
        sh:targetClass  cim:GeneratingUnit , cim:WindGeneratingUnit , cim:HydroGeneratingUnit , cim:NuclearGeneratingUnit , cim:SolarGeneratingUnit , cim:ThermalGeneratingUnit .

equ:GeneratingUnit.nominalP-valueRange
        a                sh:PropertyShape ;
        sh:description   "The attribute shall be a positive value." ;
        sh:message       "The value is negative or zero." ;
        sh:minExclusive  "0.0"^^xsd:float ;
        sh:name          "C:301:EQ:GeneratingUnit.nominalP:valueRange" ;
        sh:path          cim:GeneratingUnit.nominalP ;
        sh:group         equ:EQ301UML ;
        sh:order         71 ;
        sh:severity      sh:Violation .

can do the job, but only if there is a single machine case, i.e a GeneratingUnit associated with a single RotatingMachine. But GeneratingUnit.RotatingMachine cardinality is 1..n, and one machine can work and another can't.

equ:GeneratingUnit.nominalP-valueRangePair
        a          sh:PropertyShape ;
        sh:path    [ sh:inversePath cim:RotatingMachine.GeneratingUnit ] ;   # value nodes = each RM
        sh:not     equ:RotatingMachine-nominalPWithinRatedSShape .          # violation when RM does NOT conform to "not-bad"

equ:RotatingMachine-nominalPWithinRatedSShape                                     #"not-bad", or GU.nominalP <= RM.ratedS
        a          sh:NodeShape ;
        sh:not     [
                a               sh:PropertyShape ;
                sh:path         ( cim:RotatingMachine.GeneratingUnit cim:GeneratingUnit.nominalP ) ;
                sh:lessThanOrEquals  cim:RotatingMachine.ratedS ;
        ] .

(I omit the rest of definitions)

[nataschake]

@VladimirAlexiev

And these are compacted versions for GeneratingUnit.nominalP-valueRangePair shape set:

• NOT(NOT nominalP <=ratedS).

equ:GeneratingUnit.nominalP-valueRangePair
        a               sh:PropertyShape ;
        sh:path         [ sh:inversePath cim:RotatingMachine.GeneratingUnit ] ;
        sh:not          [ sh:not [ sh:path ( cim:RotatingMachine.GeneratingUnit cim:GeneratingUnit.nominalP ) ;
                                              sh:lessThanOrEquals  cim:RotatingMachine.ratedS ] ] ;
        sh:description  "The attribute shall be equal to or less than RotatingMachine.ratedS." ;
        sh:message      "The value is greater than RotatingMachine.ratedS for at least one associated RotatingMachine." ;
        sh:name         "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:group        equ:EQ301UML ;
        sh:order        71 ;
        sh:severity     sh:Violation .

• without NOT

equ:GeneratingUnit.nominalP-valueRangePair
        a               sh:PropertyShape ;
        sh:path         [ sh:inversePath cim:RotatingMachine.GeneratingUnit ] ;
        sh:node         [ sh:property [ sh:path ( cim:RotatingMachine.GeneratingUnit cim:GeneratingUnit.nominalP ) ;
                                                          sh:lessThanOrEquals  cim:RotatingMachine.ratedS ] ] ;
        sh:description  "The attribute shall be equal to or less than RotatingMachine.ratedS." ;
        sh:message      "The value is greater than RotatingMachine.ratedS for the associated RotatingMachine." ;
        sh:name         "C:301:EQ:GeneratingUnit.nominalP:valueRangePair" ;
        sh:group        equ:EQ301UML ;
        sh:order        71 ;
        sh:severity     sh:Violation .

I think the faster solution - the better, but have to check timings

[nataschake]

The solution with NOT against RelicapGrid evaluated in 0,286s
The solution without NOT - in 0,268s, slightly less.
Evidence here, row 17