Predicate Calculus Sketches

[AdamSobieski]

Below are some rough-draft sketches of representing n-ary predicate calculus in TriG. In planning domains, operators' preconditions and effects utilize n-ary predicate calculus expressions. The predicates utilized in these expressions are defined and interrelated in the planning domains.

I’m exploring how OWL2, SHACL, and DASH (e.g., dash:ListShape) work with lists, towards being able to efficiently validate data containing n-ary predicate calculus expressions using their predicates' definitions. Is a predicate defined correctly? Does an expression’s argument list have the correct number of elements, as described by the expression's predicate's arity? Are an expression's arguments of the correct types, as described by the expression's predicate's definition?

I'm also looking at reifying n-ary predicate calculus expressions, where calculus:Expression could be a subclass of rdf:Statement with constraints that a reified expression's rdf:subject value would be of type calculus:Predicate, its rdf:predicate could be omitted as it would be calculus:holdsFor, and its rdf:object value would be list shaped.

Possibilities for defining n-ary predicates also include considering predicates to be as functions (see also: the Function Ontology) which receive a number of typed input arguments and return expressions, e.g., calculus:Expression or subclasses thereof. Each predicate could be defined as returning instances of a predicate-specific subclass of calculus:Expression.

With respect to reification and nested expressions, I'm also looking at combining typed arguments with nestable expressions, e.g., p3(p4(x, y, z), w), perhaps utilizing calculus:Expression or predicate-specific subclasses thereof.

@prefix calculus: <http://www.w3.org/community/planning/calculus/ontology#> .
@prefix example:  <http://example.org/#> .
@prefix owl:      <http://www.w3.org/2002/07/owl#> .
@prefix rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd:      <http://www.w3.org/2001/XMLSchema#> .

example:x  rdf:type  calculus:Variable .

example:y  rdf:type  calculus:Variable .

example:z  rdf:type  calculus:Variable .

example:p1  rdf:type      calculus:Predicate ;
        calculus:accepts  ( owl:Thing owl:Thing owl:Thing ) ;
        calculus:arity    "3"^^xsd:int .

example:p2  rdf:type      calculus:Predicate ;
        calculus:accepts  ( owl:Thing owl:Thing owl:Thing ) ;
        calculus:arity    "3"^^xsd:int .

example:g1  rdf:type  calculus:ConjunctiveExpressionSet .

example:g2  rdf:type  calculus:ConjunctiveExpressionSet .

example:g3  rdf:type  calculus:ConjunctiveExpressionSet .

example:g1 {
    example:p1  calculus:holdsFor  ( example:x example:y example:z ) .
}

example:g2 {
    example:p2  calculus:holdsFor  ( example:x example:y example:z ) .
}

example:g3 {
    example:g1  calculus:implies  example:g2 .
    ### or calculus:implies  calculus:holdsFor  ( example:g1 example:g2 ) . ?
}

I enjoy the simple TriG syntax for n-ary predicate calculus expressions:

example:p1  calculus:holdsFor  ( example:x example:y example:z ) .

In my opinion, remaining matters for consideration include how best to semantically define predicates.

Here is a rough-draft sketch of the potential applicability of FnO to the definition of predicates:

@prefix calculus: <http://www.w3.org/community/planning/calculus/ontology#> .
@prefix dc:       <http://purl.org/dc/elements/1.1/> .
@prefix example:  <http://example.org/#> .
@prefix fno:      <http://w3id.org/function/ontology#> .
@prefix fnoc:     <http://w3id.org/function/vocabulary/composition#> .
@prefix fnoi:     <http://w3id.org/function/vocabulary/implementation#> .
@prefix fnom:     <http://w3id.org/function/vocabulary/mapping#> .
@prefix owl:      <http://www.w3.org/2002/07/owl#> .
@prefix plan:     <http://www.w3.org/community/planning/> .
@prefix rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:     <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd:      <http://www.w3.org/2001/XMLSchema#> .

example:myPredicate  rdf:type  calculus:Predicate , fno:Function ;
        fno:expects  ( example:myPredicate_x example:myPredicate_y example:myPredicate_z ) ;
        fno:returns  ( example:myPredicate_return ) .

example:myPredicate_x
        rdf:type      fno:Parameter ;
        fno:required  true ;
        fno:type      owl:Thing .

example:myPredicate_y
        rdf:type      fno:Parameter ;
        fno:required  true ;
        fno:type      owl:Thing .

example:myPredicate_z
        rdf:type      fno:Parameter ;
        fno:required  true ;
        fno:type      owl:Thing .

example:myPredicate_return
        rdf:type      fno:Output ;
        fno:required  true ;
        fno:type      example:MyPredicateExpression .

example:MyPredicateExpression
        rdf:type         owl:Class ;
        rdfs:subClassOf  calculus:Expression .

Any thoughts on these topics?

[dbooth-boston]

Referencing this issue on n-ary predicates: w3c/EasierRDF#20

[AdamSobieski]

Probabilistic Logic

With respect to n-ary predicate calculus, we can also consider the matter of probabilistic logic. Some approaches are indicated.

Reifying Truth Values

Firstly, we could reify expressions' truth values as arguments:

example:myPredicate  calculus:holdsFor  ( true  example:x  example:y  example:z ) .

example:myPredicate  calculus:holdsFor  ( "0.95"^^xsd:double  example:x  example:y  example:z ) .

Reifying Expressions

Secondly, we could reify expressions and describe them with probability scores:

example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z ) .

[]  rdf:type              rdf:Statement ;
    rdf:subject           example:myPredicate ;
    rdf:predicate         calculus:holdsFor ;
    rdf:object            ( example:x  example:y  example:z ) ;
    calculus:probability  "0.95"^^xsd:double .

Noteworthy is that, by means of OWL restrictions, we can omit much of the redundant information when describing reified expressions.

example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z ) .

[]  rdf:type              calculus:Expression ;
    rdf:subject           example:myPredicate ;
    rdf:object            ( example:x  example:y  example:z ) ;
    calculus:probability  "0.95"^^xsd:double .

example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z ) .

[]  rdf:type              example:MyPredicateExpression ;
    rdf:object            ( example:x  example:y  example:z ) ;
    calculus:probability  "0.95"^^xsd:double .

RDF-star, Turtle-star, and TriG-star

RDF-star, Turtle-star and TriG-star include syntax for quoting statements and for annotating asserted statements.

The following example shows the syntax for annotating an asserted n-ary predicate calculus expression with a probability:

example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z )  {| calculus:probability "0.95"^^xsd:double |} .

The following example shows a quoted expression utilized in a statement.

<< example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z ) >>  calculus:probability "0.95"^^xsd:double .

However, having a list as the object of a quoted triple isn't valid Turtle-star syntax, so the example might resemble:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix calculus: <http://www.w3.org/community/planning/calculus/ontology#> .
@prefix example: <http://example.org/#> .

_:b0    rdf:rest   _:b1 ;
        rdf:first  example:x .

_:b1    rdf:rest   _:b2 ;
        rdf:first  example:y .

_:b2    rdf:rest   rdf:nil ;
        rdf:first  example:z .

<< example:myPredicate calculus:holdsFor _:b0 >>
        calculus:probability  "0.95"^^xsd:double .

or

@prefix calculus: <http://www.w3.org/community/planning/calculus/ontology#> .
@prefix example:  <http://example.org/#> .
@prefix rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd:      <http://www.w3.org/2001/XMLSchema#> .

<< example:myPredicate calculus:holdsFor _:b0 >>
         calculus:probability  "0.95"^^xsd:double .

_:b0 rdf:first example:x ; rdf:rest ( example:y example:z ) .

@afs suggests, citing a previous discussion, that we might want to introduce a level of indirection for these scenarios, resembling:

<< example:myPredicate calculus:holdsFor _:b0 >> 
    other:observation [ calculus:probability "0.95"^^xsd:double ; other:accordingTo ex:Alice ] ;
    other:observation [ calculus:probability "0.96"^^xsd:double ; other:accordingTo ex:Bob ] .

_:b0 rdf:first example:x ; rdf:rest ( example:y example:z ) .

Describing Named Graphs

Thirdly, we could describe named graphs.

example:graph1 {
    example:myPredicate  calculus:holdsFor  ( example:x  example:y  example:z ) .
}
example:graph1 calculus:probability "0.95"^^xsd:double .