Re: abstract syntax for SHACL

We should be clear that this Abstract Syntax is only for the Core 
language of SHACL. I believe a more general Abstract Syntax would need 
to be starting with the extension mechanism, and then use itself to 
describe the core vocab.

But I guess if the goal is to create a linkage between ShEx and SHACL, 
then this doesn't matter much.

Holger


On 1/07/2016 1:12, Eric Prud'hommeaux wrote:
> finishing the remaining Parameters...
>
> * Eric Prud'hommeaux <eric@w3.org> [2016-06-29 11:30-0400]
>> In order to tie the surface syntax of ShEx to SHACL, I wrote up an
>> abstract syntax for SHACL. I tried to use the same types as described
>> in the SHACL document but I'd like folks to check it for consistency.
>>
>> Notation
>>    TypeName := label1:Type1, label2:Set[Type2]
>> means TypeName has two component addressed by label1 and label2.
>> label1 is a Type1 (defined elsewhere in the abstract syntax or in
>> RDF standards) and label2 is a set of things matching Type2.
> Schema        := shapes:Set[Shape]
>    A Schema is a set of Shapes. (Do we care about schema boundaries?)
>
> Shape         := label:IRI|BNode, scopes:Set[Scope],
>                filters:Set[Shape], constraints:Set[Constraint]
>    A Shape has a label of some IRI or BNode, and sets of scopes, filter
>    shapes and constraints.
>    The "in-scope" nodes are the nodes in the data graph which
>      1 match any of the scopes.
>      2 pass all of the filter Shapes. (Scopes in filter Shapes have no
>        effect.)
>    Validation returns the set of errors returned from testing each
>    constraint against each "focus node" in the in-scope node.
>
> # Scopes
> Scope         := ScopeNode|ScopeClass|PropertyScope|InversePropertyScope
>    A Scope is either a ScopeNode or a ScopeClass or a PropertyScope.
>
> ScopeNode     := node:IRI|Bnode # later demands told bnodes.
>    A ScopeNode matches node in the data graph.
>
> ScopeClass    := type:IRI
>    A ScopeClass matches any node in the data graph with the triple
>    (node, rdf:type, type).
>
> PropertyScope := predicate:IRI
>    A PropertyScope matches any node in the data graph with a triple
>    (node, predicate, _) where "_" is any node.
>
> InversePropertyScope := predicate:IRI
>    A PropertyScope matches any node in the data graph with a triple
>    (_, predicate, node) where "_" is any node.
>
> # Constraints
> Constraint    := NodeConstraint|PropertyConstraint|
>                   InversePropertyConstraint|Constraint
>
>    A Constraint is either PropertyConstraint or InversePropertyConstraint
>    or a NodeConstraint. Each type of Constraint selects a value node
>    and tests it against a set of Paramenters. Parameters take
>    arguments, including "numeric" which is the set of SPARQL numeric
>    types enumerated in SPARQL Operand Data Types
>    <http://www.w3.org/TR/sparql11-query/#operandDataTypes>.
>
>    Exceptions: three Parameters, MinCount, MaxCount, and UniqueLang are
>    evaluated against the set of all value nodes identified for testing
>    by PropertyConstraint or InversePropertyConstraint.
>
>    Three other Parameters, QualifiedMinCount, QualifiedMaxCount, and
>    QualifiedValueShape, are evaluated against the set of all value
>    nodes identified for testing by PropertyConstraint or
>    InversePropertyConstraint and for which the evaluation of all other
>    Parameters returned no errors.
>
> NodeConstraint := parms:Set[NCParameter]
>    Testing a NodeConstraint against a focus node returns all of the
>    errors from testing each NCParameter against the the value node
>    where the value node is the focus node.
>
> PropertyConstraint := predicate:IRI, parms:Set[PCParameter]
>    Testing a NodeConstraint against a focus node returns all of the errors
>    from testing each NCParameter against each value node in the triple
>    (focus node, predicate, value node).
>
> InversePropertyConstraint := predicate:IRI, parms:Set[IPCParameter]
>    Testing a NodeConstraint against a focus node returns all of the errors
>    from testing each NCParameter against each value node in the triple
>    (value node, predicate, focus node).
>
> Constraint    := @@still fuzzy on what's permitted in a general constraint.
>    Extrapolate from Closed?
>
>
> NP, PC and IPC Parameters are listed in the first table in
> <http://w3c.github.io/data-shapes/shacl/#h-constraints>.
>
> # Nary Parameters - evaluate a set of value nodes.
> ## Cardinality: PC, ICP
> MinCount      := ref:numeric
>    Testing a MinCount parameter against a set of value nodes returns an
>    error if the number of value nodes is less than ref.
> QualifiedMinCount := ref:numeric
>    As noted above, QualifiedMinCount takes a set of value nodes that
>    have passed all non-cardinality tests. It's evaluation is the same
>    as the evaluation of MinCount.
>
> MaxCount      := ref:numeric
>    Testing a MaxCount parameter against a set of value nodes returns an
>    error if the number of value nodes is greater than ref.
> QualifiedMaxCount := ref:numeric
>    As noted above, QualifiedMaxCount takes a set of value nodes that
>    have passed all non-cardinality tests. It's evaluation is the same
>    as the evaluation of MaxCount.
>
> UniqueLang    := b:boolean
>    Testing a UniqueLang parameter against a set of value nodes returns an
>    error if two or more of the value nodes are RDFLiterals with the same
>    language tag.
>
> # Unary Parameters - evaluate a single value node.
> ## Logical operators: NC, PC, IPC
> And           := shapes:Set[Shape]
>    Testing an And parameter against a value node returns the errors from
>    testing each of shapes against the value node.
>
> Or            := shapes:Set[Shape]
>    Testing an Or parameter against a value node returns an unspecified
>    error if testing each of shapes against the value node returned an
>    error.
>    
> Not           := shape:Shape
>    Testing an Or parameter against a value node returns an unspecified
>    error if testing shape against the value node returned no
>    error.
>
> ## RDF term type of value node: NC, PC, IPC
> NodeKind      := kind:"IRI"|"blank node"|"literal"
>    Testing a NodeKind parameter against a value node returns an error if
>      • kind = "IRI" and value node is not an IRI
>      • kind = "blank node" and value node is not an blank node
>      • kind = "literal" and value node is not an RDFLiteral
>
> ## RDF term equivalence: NC, PC, IPC
> HasValue      := val:RDF term @@ listed as PC, IPC as of 2016-06-30
>    Testing a HasValue parameter against a value node returns an error if
>    the value node is a different RDF term than val.
>
> In            := vals:Set[RDF term]
>    Testing a HasValue parameter against a value node returns an error if
>    the value node is not in vals.
>
> ## Datatype: NC, PC
> Datatype      := dt:IRI
>    Testing a Datatype parameter against a value node returns an error if
>    the value node is not an RDFLiteral or of the datatype of the value
>    node is not the same RDF term as dt.
>
> DatatypeIn    := dts:Set[IRI]
>    Testing a Datatype parameter against a value node returns an error if
>    the value node is not an RDFLiteral or of the datatype of the value
>    node is not the set dts.
>
> ## lexical form parameters:
> ### XML Schema string facets: NC, PC, ICP
> MinLength     := ref:numeric
>    Testing a MinLength paramenter against a value node returns an error
>    if the lexical form of the value node is longer than ref.
>
> MaxLength     := ref:numeric
>    Testing a MinLength paramenter against a value node returns an error
>    if the lexical form of the value node is shorter than ref.
>
> Pattern       := pat:RDFLiteral
>    Testing a Pattern paramenter against a value node returns an error
>    if evaluating the SPARQL regex function with the lexical form of
>    value node and pat is false or results in a type error.
>
> Stem          := str:RDFLiteral
>    Testing a Stem parameter against a value node returns an error if
>    the value node is not an IRI or the lexical form of the value node
>    does not start with str.
>
> ## RDFLiteral value parameters
> ### XML Schema numeric facets: NC, PC
> MaxExclusive  := ref:RDFLitera
>    Testing a MaxExclusive parameter against a value node returns an
>    error if the evaluation of (value node > ref) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> MaxInclusive  := ref:RDFLiteral
>    Testing a MaxExclusive parameter against a value node returns an
>    error if the evaluation of (value node >= ref) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> MinExclusive  := ref:RDFLiteral
>    Testing a MaxExclusive parameter against a value node returns an
>    error if the evaluation of (value node > ref) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> MinInclusive  := ref:RDFLiteral
>    Testing a MaxExclusive parameter against a value node returns an
>    error if the evaluation of (value node >= ref) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> ## Comparison with sibling property: PC
> Equals        := sibling:RDFLiteral
>    Testing an Equals parameter against a value node returns an
>    error if there is no node v in (focus node, sibling, v) in the data
>    graph or the evaluation of (value node = v) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> LessThan      := sibling:RDFLiteral
>    Testing an LessThan parameter against a value node returns an
>    error if there is no node v in (focus node, sibling, v) in the data
>    graph or the evaluation of (value node < v) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> LessThanEquals := sibling:RDFLiteral
>    Testing an LessThanEquals parameter against a value node returns an
>    error if there is no node v in (focus node, sibling, v) in the data
>    graph or the evaluation of (value node <= v) in SPARQL1.1 Operator
>    Mapping returns false or results in a type error.
>
> Disjoint      := sibling:RDFLiteral
>    Testing an Disjoint parameter against a value node returns an
>    error if any node v in (focus node, sibling, v) in the data graph
>    or the evaluation of (value node < v) in SPARQL1.1 Operator Mapping
>    returns false or results in a type error.
>
> ## Nested shape constraints: PC, IPC
> Shape         := nested:Shape @@  listed as NC, PC, IPC as of 2016-06-30
>    Testing a Shape parameter against a value node returns any errors
>    returned when validating the value node as nested (c.f. definition
>    of Shape above).
> QualifiedValueShape := nested:Shape
>    As noted above, QualifiedValueShape takes a set of value nodes that
>    have passed all non-cardinality tests. It's evaluation is the same
>    as the evaluation of Shape.
>
> Class         := t:IRI @@ + subClassOf*
>    Testing a Class parameter against a value node returns any errors
>    returned when validating the value node as a Shape with a single
>    PropertyConstraint with a predicate(rdf:type) and HasValue(t).
>
> ClassIn       := t:IRI @@ + subClassOf*
>    Testing a ClassIn parameter against a value node returns any errors
>    returned when validating the value node as a Shape with a single
>    PropertyConstraint with a predicate(rdf:type) and In(t).
>

Received on Sunday, 3 July 2016 02:30:52 UTC