Approved BLD Test for arbitrary entailment from inconsistent ruleset An inconsistent RIF document entails any formula. This particular RIF document is inconsistent (i.e., it has no model) because it asserts equality between the strings "a" and "b", which are known to be different by the [http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#string XML schema datatypes specification]. Arbitrary_Entailment-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Arbitrary_Entailment/Arbitrary_Entailment-premise.rif Arbitrary_Entailment-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Arbitrary_Entailment/Arbitrary_Entailment-conclusion.rif () ]]> Approved Core BLD PRD Test built-in predicates for XML Schema anyURI datatype Builtins_anyURI-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_anyURI/Builtins_anyURI-premise.rif ) Prefix(ex ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-anyURI( "http://www.example.org"^^xs:anyURI ) ) External( pred:is-literal-not-anyURI("1"^^xs:integer ) ) External( pred:is-literal-anyURI( External ( xs:anyURI ( "http://www.example.org"^^xs:string ) ) ) ) ) ) ) ]]> Builtins_anyURI-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_anyURI/Builtins_anyURI-conclusion.rif Approved Core BLD PRD Test built-in predicates for XML Schema binary datatypes Builtins_Binary-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Binary/Builtins_Binary-premise.rif ) Prefix(ex ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-hexBinary( "aabb"^^xs:hexBinary ) ) External( pred:is-literal-base64Binary( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/+0123456789"^^xs:base64Binary ) ) External( pred:is-literal-not-base64Binary( "foo"^^xs:string ) ) External( pred:is-literal-base64Binary( External ( xs:base64Binary ( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/+0123456789"^^xs:string ) ) ) ) ) ) ) ]]> Builtins_Binary-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Binary/Builtins_Binary-conclusion.rif Approved Core BLD PRD Test built-in predicates for XML Schema boolean datatype Builtins_boolean-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_boolean/Builtins_boolean-premise.rif ) Prefix(pred ) Prefix(ex ) Group ( ex:ok() :- And ( External( pred:is-literal-boolean( "1"^^xs:boolean ) ) External( pred:is-literal-not-boolean( "foo"^^xs:string ) ) External( pred:is-literal-boolean( External ( xs:boolean ( "1"^^xs:string ) ) ) ) External ( pred:boolean-equal( "0"^^xs:boolean "0"^^xs:boolean ) ) External ( pred:boolean-less-than( "0"^^xs:boolean "1"^^xs:boolean ) ) External ( pred:boolean-greater-than( "1"^^xs:boolean "0"^^xs:boolean ) ) ) ) ) ]]> Builtins_boolean-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_boolean/Builtins_boolean-conclusion.rif Approved Core BLD PRD Test RIF list built-in predicates and functions Builtins_List-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_List/Builtins_List-premise.rif ) Prefix(func ) Prefix(pred ) Group ( ex:ok() :- And ( External(pred:is-list(List(0 1 2 List(3 4)))) External(pred:list-contains(List(0 1 2 3 List(7 8)) List(7 8))) External( func:make-list(0 1 2) ) = List(0 1 2) External(func:count(List(0 1 2 3 4))) = 5 External( func:get(List(0 1 2 3 4) -1) ) = 4 External( func:sublist(List(0 1 2 3 4) 0 5) ) = List(0 1 2 3 4) External( func:append(List(0 1 2) 3 4) ) = List(0 1 2 3 4) External( func:concatenate(List(0 1 2) List(3 4 5)) ) = List(0 1 2 3 4 5) External( func:insert-before(List(0 1 2 3 4) -1 99) ) = List(0 1 2 3 99 4) External( func:remove(List(0 1 2 3 4) -5) ) = List(1 2 3 4) External( func:reverse(List(0 1 2 3 4)) ) = List(4 3 2 1 0) External( func:index-of(List(0 1 2 3 4 5 2 2) 2) ) = List(2 6 7) External( func:union(List(0 1 2 3) List(4)) ) = List(0 1 2 3 4) External( func:distinct-values(List(3 3 3)) ) = List(3) External( func:intersect(List(0 1 2 3 4) List(3 1)) ) = List(1 3) External( func:except(List(0 1 2 3 4) List(1 3)) ) = List(0 2 4) ) ) ) ]]> Builtins_List-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_List/Builtins_List-conclusion.rif Approved Core BLD PRD Test built-in predicates and functions for XML Schema numeric datatypes Builtins_Numeric-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Numeric/Builtins_Numeric-premise.rif ) Prefix(ex ) Prefix(func ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-double( "1.2E34"^^xs:double ) ) External( pred:is-literal-float( "-INF"^^xs:float ) ) External( pred:is-literal-decimal( "1"^^xs:integer ) ) External( pred:is-literal-integer( "1"^^xs:integer ) ) External( pred:is-literal-long( "1"^^xs:integer ) ) External( pred:is-literal-int( "1"^^xs:integer ) ) External( pred:is-literal-short( "1"^^xs:integer ) ) External( pred:is-literal-byte( "1"^^xs:integer ) ) External( pred:is-literal-nonNegativeInteger( "1"^^xs:integer ) ) External( pred:is-literal-positiveInteger( "1"^^xs:integer ) ) External( pred:is-literal-unsignedLong( "1"^^xs:integer ) ) External( pred:is-literal-unsignedInt( "1"^^xs:integer ) ) External( pred:is-literal-unsignedShort( "1"^^xs:integer ) ) External( pred:is-literal-unsignedByte( "1"^^xs:integer ) ) External( pred:is-literal-nonPositiveInteger( "-1"^^xs:integer ) ) External( pred:is-literal-negativeInteger( "-1"^^xs:integer ) ) External( pred:is-literal-not-double( "foo"^^xs:string ) ) External( pred:is-literal-not-float( "foo"^^xs:string ) ) External( pred:is-literal-not-hexBinary( "foo"^^xs:string ) ) External( pred:is-literal-not-decimal( "foo"^^xs:string ) ) External( pred:is-literal-not-integer( "foo"^^xs:string ) ) External( pred:is-literal-not-long( "foo"^^xs:string ) ) External( pred:is-literal-not-int( "foo"^^xs:string ) ) External( pred:is-literal-not-short( "foo"^^xs:string ) ) External( pred:is-literal-not-byte( "foo"^^xs:string ) ) External( pred:is-literal-not-nonNegativeInteger( "foo"^^xs:string ) ) External( pred:is-literal-not-positiveInteger( "foo"^^xs:string ) ) External( pred:is-literal-not-unsignedLong( "foo"^^xs:string ) ) External( pred:is-literal-not-unsignedInt( "foo"^^xs:string ) ) External( pred:is-literal-not-unsignedShort( "foo"^^xs:string ) ) External( pred:is-literal-not-unsignedByte( "foo"^^xs:string ) ) External( pred:is-literal-not-nonPositiveInteger( "foo"^^xs:string ) ) External( pred:is-literal-not-negativeInteger( "foo"^^xs:string ) ) External( pred:is-literal-double( External ( xs:double ("1.2E34"^^xs:string ) ) ) ) External( pred:is-literal-float( External ( xs:float ( "-1"^^xs:string ) ) ) ) External( pred:is-literal-hexBinary( External ( xs:hexBinary ( "aabb"^^xs:string ) ) ) ) External( pred:is-literal-decimal( External( xs:decimal ( "1"^^xs:string ) ) ) ) External( pred:is-literal-integer( External( xs:integer ( "1"^^xs:string ) ) ) ) External( pred:is-literal-long( External( xs:long ( "1"^^xs:string ) ) ) ) External( pred:is-literal-int( External( xs:int ( "1"^^xs:string ) ) ) ) External( pred:is-literal-short( External( xs:short ( "1"^^xs:string ) ) ) ) External( pred:is-literal-byte( External( xs:byte ( "1"^^xs:string ) ) ) ) External( pred:is-literal-nonNegativeInteger( External( xs:nonNegativeInteger ( "1"^^xs:string ) ) ) ) External( pred:is-literal-positiveInteger( External( xs:positiveInteger ( "1"^^xs:string ) ) ) ) External( pred:is-literal-unsignedLong( External( xs:unsignedLong ( "1"^^xs:string ) ) ) ) External( pred:is-literal-unsignedInt( External( xs:unsignedInt ( "1"^^xs:string ) ) ) ) External( pred:is-literal-unsignedShort( External( xs:unsignedShort ( "1"^^xs:string ) ) ) ) External( pred:is-literal-unsignedByte( External( xs:unsignedByte ( "1"^^xs:string ) ) ) ) External( pred:is-literal-nonPositiveInteger( External( xs:nonPositiveInteger ("-1"^^xs:string ) ) ) ) External( pred:is-literal-negativeInteger( External( xs:negativeInteger ("-1"^^xs:string ) ) ) ) 2 = External ( func:numeric-add( 1 1 ) ) 1 = External ( func:numeric-subtract( 2 1 ) ) 6 = External ( func:numeric-multiply( 2 3 ) ) 2 = External ( func:numeric-divide( 6 3 ) ) 1 = External ( func:numeric-integer-divide( 5 3 ) ) 2 = External ( func:numeric-integer-mod( 5 3 ) ) External ( pred:numeric-equal( "0.0E0"^^xs:double External ( func:numeric-subtract( 1 1 ) ) ) ) External ( pred:numeric-not-equal( 0 1 ) ) External ( pred:numeric-less-than ( 1 2 ) ) External ( pred:numeric-less-than-or-equal ( 1 2 ) ) External ( pred:numeric-less-than-or-equal ( 1 1 ) ) External ( pred:numeric-greater-than ( 2 -1 ) ) External ( pred:numeric-greater-than-or-equal ( 2 -1 ) ) External ( pred:numeric-greater-than-or-equal ( 2 2 ) ) External ( pred:numeric-not-equal( 0 1 ) ) ) ) ) ]]> Builtins_Numeric-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Numeric/Builtins_Numeric-conclusion.rif Approved Core BLD PRD Test built-in predicates and functions for RDF PlainLiteral datatype Builtins_PlainLiteral-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_PlainLiteral/Builtins_PlainLiteral-premise.rif ) Prefix(rdf ) Prefix(ex ) Prefix(func ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-PlainLiteral( "Hello world@en"^^rdf:PlainLiteral ) ) External( pred:is-literal-PlainLiteral( "Hello world@"^^rdf:PlainLiteral ) ) External( pred:is-literal-not-PlainLiteral( "1"^^xs:integer ) ) External( pred:is-literal-PlainLiteral( External( rdf:PlainLiteral ("1"^^xs:integer ) ) ) ) External( func:PlainLiteral-from-string-lang( "Hello World!" "en" ) ) = "Hello World!"@en External( func:string-from-PlainLiteral( "Hello World!"@en ) ) = "Hello World!" External( func:string-from-PlainLiteral( "Hello World!@en" ) )= "Hello World!@en" External( func:lang-from-PlainLiteral( "Hello World!@en"^^rdf:PlainLiteral ) )= "en"^^xs:lang External( func:lang-from-PlainLiteral( "Hello World!@en" ) ) = "" -1 = External ( func:PlainLiteral-compare( "hallo"@de "welt"@de ) ) 1 = External ( func:PlainLiteral-compare( "welt"@de "hallo"@de ) ) 0 = External ( func:PlainLiteral-compare( "hallo"@de "hallo"@de ) ) External ( pred:matches-language-range( "Schlagobers ist dasselbe wie Schlagsahne."@de-at "de-*" ) ) ) ) ) ]]> Builtins_PlainLiteral-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_PlainLiteral/Builtins_PlainLiteral-conclusion.rif Approved Core BLD PRD Test built-in predicates and functions for XML schema string datatypes Note the somewhat surprising results on substring. RIF follows [http://www.w3.org/TR/xpath-functions/#func-substring XPath] on this. Builtins_String-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_String/Builtins_String-premise.rif ) Prefix(rdf ) Prefix(ex ) Prefix(func ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-string( "Hello world@"^^rdf:PlainLiteral ) ) External( pred:is-literal-string( "Hello world"^^xs:string ) ) External( pred:is-literal-normalizedString( "Hello world"^^xs:string ) ) External( pred:is-literal-token( "Hello world"^^xs:string ) ) External( pred:is-literal-language( "en"^^xs:language ) ) External( pred:is-literal-Name( "Hello"^^xs:Name ) ) External( pred:is-literal-NCName( "Hello"^^xs:NCName ) ) External( pred:is-literal-NMTOKEN( "Hello"^^xs:NMTOKEN ) ) External( pred:is-literal-not-string( "1"^^xs:integer ) ) External( pred:is-literal-not-normalizedString( "1"^^xs:integer ) ) External( pred:is-literal-not-token( "1"^^xs:integer ) ) External( pred:is-literal-not-language( "1"^^xs:integer ) ) External( pred:is-literal-not-Name( "1"^^xs:integer ) ) External( pred:is-literal-not-NCName( "1"^^xs:integer ) ) External( pred:is-literal-not-NMTOKEN( "1"^^xs:integer ) ) External( pred:is-literal-string( External( xs:string ("1"^^xs:integer ) ) ) ) External( pred:is-literal-normalizedString( External( xs:normalizedString ("1"^^xs:integer ) ) ) ) External( pred:is-literal-token( External( xs:token( "de"^^xs:hexBinary ) ) ) ) External( pred:is-literal-language( External ( xs:language ( "de"^^xs:hexBinary ) ) ) ) External( pred:is-literal-Name( External ( xs:Name ( "de"^^xs:hexBinary ) ) ) ) External( pred:is-literal-NCName( External ( xs:NCName ( "de"^^xs:hexBinary ) ) ) ) External( pred:is-literal-NMTOKEN( External ( xs:NMTOKEN ( "de"^^xs:hexBinary ) ) ) ) External( pred:iri-string( "http://www.example.org" ) ) -1 = External ( func:compare( "bar" "foo" ) ) 1 = External ( func:compare( "foo" "bar" ) ) 0 = External ( func:compare( "bar" "bar" ) ) "foobar" = External ( func:concat( "foo" "bar" ) ) "foo,bar" = External ( func:string-join( "foo" "bar" "," ) ) "bar" = External ( func:substring( "foobar" 3 ) ) "fo" = External ( func:substring( "foobar" 0 3 ) ) 3 = External ( func:string-length( "foo" ) ) "FOOBAR" = External ( func:upper-case( "FooBar" ) ) "foobar" = External ( func:lower-case( "FooBar" ) ) "RIF%20Basic%20Logic%20Dialect" = External ( func:encode-for-uri( "RIF Basic Logic Dialect" ) ) "http://www.example.com/~b%C3%A9b%C3%A9" = External ( func:iri-to-uri ( "http://www.example.com/~bébé" ) ) "javascript:if (navigator.browserLanguage == 'fr') window.open('http://www.example.com/~b%C3%A9b%C3%A9');" = External ( func:escape-html-uri ( "javascript:if (navigator.browserLanguage == 'fr') window.open('http://www.example.com/~bébé');" ) ) "foo" = External ( func:substring-before( "foobar" "bar" ) ) "bar" = External ( func:substring-after( "foobar" "foo" ) ) "[1=ab][2=]cd" = External ( func:replace( "abcd" "(ab)|(a)" "[1=$1][2=$2]" ) ) External( pred:contains ( "foobar" "foo" ) ) External( pred:starts-with ( "foobar" "foo" ) ) External( pred:ends-with ( "foobar" "bar" ) ) External( pred:matches ( "abracadabra" "^a.*a$" ) ) ) ) ) ]]> Builtins_String-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_String/Builtins_String-conclusion.rif Approved Core BLD PRD Test built-in predicates and functions for XML Schema date, time and duration datatypes Builtins_Time-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Time/Builtins_Time-premise.rif ) Prefix(rdf ) Prefix(ex ) Prefix(func ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-date ( "2000-12-13-11:00"^^xs:date ) ) External( pred:is-literal-dateTime ( "2000-12-13T00:11:11.3"^^xs:dateTime ) ) External( pred:is-literal-dateTimeStamp ( "2000-12-13T00:11:11.3Z"^^xs:dateTimeStamp ) ) External( pred:is-literal-time ( "00:11:11.3Z"^^xs:time ) ) External( pred:is-literal-dayTimeDuration ( "P3DT2H"^^xs:dayTimeDuration ) ) External( pred:is-literal-yearMonthDuration ( "P1Y2M"^^xs:yearMonthDuration ) ) External( pred:is-literal-not-date ( "foo"^^xs:string ) ) External( pred:is-literal-not-dateTime ( "foo"^^xs:string ) ) External( pred:is-literal-not-dateTimeStamp ( "foo"^^xs:string ) ) External( pred:is-literal-not-time ( "foo"^^xs:string ) ) External( pred:is-literal-not-dayTimeDuration ( "foo"^^xs:string ) ) External( pred:is-literal-not-yearMonthDuration ( "foo"^^xs:string ) ) External( pred:is-literal-date ( External ( xs:date ( "2000-12-13-11:00"^^xs:string ) ) ) ) External( pred:is-literal-dateTime ( External ( xs:dateTime ( "2000-12-13T00:11:11.3"^^xs:string ) ) ) ) External( pred:is-literal-dateTimeStamp ( External ( xs:dateTimeStamp ( "2000-12-13T00:11:11.3Z"^^xs:string ) ) ) ) External( pred:is-literal-time ( External ( xs:time ( "00:11:11.3Z"^^xs:string ) ) ) ) External( pred:is-literal-dayTimeDuration ( External ( xs:dayTimeDuration ( "P3DT2H"^^xs:string ) ) ) ) External( pred:is-literal-yearMonthDuration ( External ( xs:yearMonthDuration ( "P1Y2M"^^xs:string ) ) ) ) External( func:year-from-dateTime( "1999-12-31T24:00:00"^^xs:dateTime ) ) = 2000 External( func:month-from-dateTime( "1999-05-31T13:20:00-05:00"^^xs:dateTime ) ) = 5 External( func:day-from-dateTime( "1999-05-31T13:20:00-05:00"^^xs:dateTime ) ) = 31 External( func:hours-from-dateTime( "1999-05-31T08:20:00-05:00"^^xs:dateTime ) ) = 8 External( func:minutes-from-dateTime( "1999-05-31T13:20:00-05:00"^^xs:dateTime ) ) = 20 External( func:seconds-from-dateTime( "1999-05-31T13:20:00-05:00"^^xs:dateTime ) ) = 0 External( func:year-from-date( "1999-12-31"^^xs:date ) ) = 1999 External( func:month-from-date( "1999-05-31"^^xs:date ) ) = 5 External( func:day-from-date( "1999-05-31"^^xs:date ) ) = 31 External( func:hours-from-time( "08:20:00-05:00"^^xs:time ) ) = 8 External( func:minutes-from-time( "13:20:00-05:00"^^xs:time ) ) = 20 External( func:seconds-from-time( "13:20:00-05:00"^^xs:time ) ) = 0 External( func:timezone-from-dateTime( "1999-05-31T13:20:00-05:00"^^xs:dateTime ) ) = "-PT5H"^^xs:dayTimeDuration External( func:timezone-from-date( "1999-05-31-05:00"^^xs:date ) ) = "-PT5H"^^xs:dayTimeDuration External( func:timezone-from-time( "13:20:00-05:00"^^xs:time) ) = "-PT5H"^^xs:dayTimeDuration External( func:years-from-duration( "P20Y15M"^^xs:yearMonthDuration ) ) = 21 External( func:months-from-duration( "P20Y15M"^^xs:yearMonthDuration ) ) = 3 External( func:days-from-duration( "P3DT10H"^^xs:dayTimeDuration ) ) = 3 External( func:hours-from-duration( "P3DT10H"^^xs:dayTimeDuration ) ) = 10 External( func:minutes-from-duration( "-P5DT12H30M"^^xs:dayTimeDuration ) ) = -30 External( func:seconds-from-duration( "P3DT10H12.5S"^^xs:dayTimeDuration ) ) = 12.5 External( func:subtract-dateTimes( "2000-10-30T06:12:00-05:00"^^xs:dateTime "1999-11-28T09:00:00Z"^^xs:dateTime) ) = "P337DT2H12M"^^xs:dayTimeDuration External( func:subtract-dates( "2000-10-30Z"^^xs:date "1999-11-28Z"^^xs:date ) ) = "P337D"^^xs:dayTimeDuration External( func:subtract-times( "11:12:00Z"^^xs:time "04:00:00Z"^^xs:time ) ) = "PT7H12M"^^xs:dayTimeDuration External( func:add-yearMonthDurations("P2Y11M"^^xs:yearMonthDuration "P3Y3M"^^xs:yearMonthDuration) ) = "P6Y2M"^^xs:yearMonthDuration External( func:subtract-yearMonthDurations("P2Y11M"^^xs:yearMonthDuration "P3Y3M"^^xs:yearMonthDuration ) ) = "-P4M"^^xs:yearMonthDuration External( func:multiply-yearMonthDuration("P2Y11M"^^xs:yearMonthDuration 2.3 ) ) = "P6Y9M"^^xs:yearMonthDuration External( func:divide-yearMonthDuration("P2Y11M"^^xs:yearMonthDuration 1.5 ) ) = "P1Y11M"^^xs:yearMonthDuration External( func:divide-yearMonthDuration-by-yearMonthDuration( "P3Y4M"^^xs:yearMonthDuration "-P1Y4M"^^xs:yearMonthDuration ) ) = -2.5 External( func:add-dayTimeDurations( "P2DT12H5M"^^xs:dayTimeDuration "P5DT12H"^^xs:dayTimeDuration) ) = "P8DT5M"^^xs:dayTimeDuration External( func:subtract-dayTimeDurations( "P2DT12H"^^xs:dayTimeDuration "P1DT10H30M"^^xs:dayTimeDuration ) ) = "P1DT1H30M"^^xs:dayTimeDuration External( func:multiply-dayTimeDuration( "PT2H10M"^^xs:dayTimeDuration 2.1 ) ) = "PT4H33M"^^xs:dayTimeDuration External( func:divide-dayTimeDuration( "P4D"^^xs:dayTimeDuration 2 ) ) = "P2D"^^xs:dayTimeDuration External( func:divide-dayTimeDuration-by-dayTimeDuration( "P4D"^^xs:dayTimeDuration "P2D"^^xs:dayTimeDuration ) ) = 2 External( func:add-yearMonthDuration-to-dateTime( "2000-10-30T11:12:00"^^xs:dateTime "P1Y2M"^^xs:yearMonthDuration ) ) = "2001-12-30T11:12:00"^^xs:dateTime External( func:add-yearMonthDuration-to-date( "2000-10-30"^^xs:date "P1Y2M"^^xs:yearMonthDuration ) ) = "2001-12-30"^^xs:date External( func:add-dayTimeDuration-to-dateTime( "2000-10-30T11:12:00"^^xs:dateTime "P3DT1H15M"^^xs:dayTimeDuration ) ) = "2000-11-02T12:27:00"^^xs:dayTime External( func:add-dayTimeDuration-to-date("2004-10-30Z"^^xs:date "P2DT2H30M0S"^^xs:dayTimeDuration ) ) = "2004-11-01Z"^^xs:date External( func:add-dayTimeDuration-to-time( "11:12:00"^^xs:time "P3DT1H15M"^^xs:dayTimeDuration ) ) = "12:27:00"^^xs:time External( func:add-dayTimeDuration-to-time( "23:12:00+03:00"^^xs:time "P1DT3H15M"^^xs:dayTimeDuration ) ) = "02:27:00+03:00"^^xs:time External( func:subtract-yearMonthDuration-from-dateTime( "2000-10-30T11:12:00"^^xs:dateTime "P1Y2M"^^xs:yearMonthDuration ) ) = "1999-08-30T11:12:00"^^xs:dateTime External( func:subtract-yearMonthDuration-from-date( "2000-10-30"^^xs:date "P1Y2M"^^xs:yearMonthDuration ) ) = "1999-08-30"^^xs:date External( func:subtract-dayTimeDuration-from-dateTime( "2000-10-30T11:12:00"^^xs:dateTime "P3DT1H15M"^^xs:dayTimeDuration ) ) = "2000-10-27T09:57:00"^^xs:dateTime External( func:subtract-dayTimeDuration-from-date( "2000-10-30"^^xs:date "P3DT1H15M"^^xs:dayTimeDuration ) ) = "2000-10-26"^^xs:date External( func:subtract-dayTimeDuration-from-time( "11:12:00"^^xs:time "P3DT1H15M"^^xs:dayTimeDuration ) ) = "09:57:00"^^xs:time External( pred:dateTime-equal( "2002-04-02T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:dateTime-less-than( "2002-04-01T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:dateTime-greater-than( "2002-04-03T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:date-equal( "2004-12-25-12:00"^^xs:date "2004-12-26+12:00"^^xs:date ) ) External( pred:date-less-than( "2004-12-24"^^xs:date "2004-12-26"^^xs:date ) ) External( pred:date-greater-than( "2004-12-26"^^xs:date "2004-12-25"^^xs:date ) ) External( pred:time-equal( "21:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:time-less-than( "20:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:time-greater-than( "22:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:duration-equal( "P1Y"^^xs:yearMonthDuration "P12M"^^xs:yearMonthDuration ) ) External( pred:yearMonthDuration-less-than( "P1Y"^^xs:yearMonthDuration "P13M"^^xs:yearMonthDuration ) ) External( pred:yearMonthDuration-greater-than( "P1Y"^^xs:yearMonthDuration "P11M"^^xs:yearMonthDuration ) ) External( pred:dayTimeDuration-less-than( "P1D"^^xs:dayTimeDuration "PT25H"^^xs:dayTimeDuration ) ) External( pred:dayTimeDuration-greater-than( "P1D"^^xs:dayTimeDuration "PT23H"^^xs:dayTimeDuration ) ) External( pred:dateTime-not-equal( "2002-04-01T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:dateTime-less-than-or-equal( "2002-04-01T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:dateTime-greater-than-or-equal( "2002-04-03T12:00:00-01:00"^^xs:dateTime "2002-04-02T17:00:00+04:00"^^xs:dateTime ) ) External( pred:date-not-equal( "2004-12-24"^^xs:date "2004-12-26"^^xs:date ) ) External( pred:date-less-than-or-equal( "2004-12-24"^^xs:date "2004-12-26"^^xs:date ) ) External( pred:date-greater-than-or-equal( "2004-12-26"^^xs:date "2004-12-25"^^xs:date ) ) External( pred:time-not-equal( "20:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:time-less-than-or-equal( "20:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:time-greater-than-or-equal( "22:30:00+10:30"^^xs:time "06:00:00-05:00"^^xs:time ) ) External( pred:duration-not-equal( "P1Y"^^xs:yearMonthDuration "P1M"^^xs:yearMonthDuration ) ) External( pred:yearMonthDuration-less-than-or-equal( "P1Y"^^xs:yearMonthDuration "P13M"^^xs:yearMonthDuration ) ) External( pred:yearMonthDuration-greater-than-or-equal( "P1Y"^^xs:yearMonthDuration "P11M"^^xs:yearMonthDuration ) ) External( pred:dayTimeDuration-less-than-or-equal( "P1D"^^xs:dayTimeDuration "PT25H"^^xs:dayTimeDuration ) ) External( pred:dayTimeDuration-greater-than-or-equal( "P1D"^^xs:dayTimeDuration "PT23H"^^xs:dayTimeDuration ) ) ) ) ) ]]> Builtins_Time-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_Time/Builtins_Time-conclusion.rif Approved Core BLD PRD Test built-in predicates for RDF XMLLiteral datatype Note that the lexical space only allows for canonical XML, so use of "<br />"^^rdf:XMLLiteral is a RIF syntax error. Builtins_XMLLiteral-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_XMLLiteral/Builtins_XMLLiteral-premise.rif ) Prefix(rdf ) Prefix(ex ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:is-literal-XMLLiteral ( "

"^^rdf:XMLLiteral ) ) External( pred:is-literal-not-XMLLiteral ( "1"^^xs:integer ) ) External( pred:is-literal-XMLLiteral ( External ( rdf:XMLLiteral( "

"^^xs:string ) ) ) ) ) ) ) ]]> Builtins_XMLLiteral-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtins_XMLLiteral/Builtins_XMLLiteral-conclusion.rif Approved Core BLD PRD Test the literal-not-identical built-in predicate. Builtin_literal-not-identical-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Builtin_literal-not-identical/Builtin_literal-not-identical-premise.rif ) Prefix(rdf ) Prefix(ex ) Prefix(pred ) Group ( ex:ok() :- And ( External( pred:literal-not-identical( "1"^^xs:integer "1"^^xs:string ) ) External( pred:literal-not-identical( "1"^^xs:integer "2"^^xs:integer ) ) External( pred:literal-not-identical( "Hello world@"^^rdf:PlainLiteral "Hello world@"^^xs:string ) ) ) ) ) ]]> Builtin_literal-not-identical-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Builtin_literal-not-identical/Builtin_literal-not-identical-conclusion.rif Approved Core BLD PRD This test highlights the different behavior of forward-chaining vs. backward-chaining engines The entailment holds, but some engines may have difficulty finding it and/or may behave badly with it. This particular test case may be hard to handle for backward-chaining engines, depending on their implementation of the func:numeric-add builtin. In a forward-chaining strategy, the entailment should be found, but since the minimal model itself is infinite, a naive engine, which tries to materialize the whole minimal model may not terminate. Chaining_strategy_numeric-add_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-add_1/Chaining_strategy_numeric-add_1-premise.rif ) Prefix(func ) Group ( Forall ?x ( ex:a(External(func:numeric-add(?x 1))) :- ex:a(?x) ) ex:a(1) ) ) ]]> Chaining_strategy_numeric-add_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-add_1/Chaining_strategy_numeric-add_1-conclusion.rif Approved BLD This test highlights the different behavior of forward-chaining vs. backward-chaining engines The entailment holds, but some engines may have difficulty finding it and/or may behave badly with it. This particular test case may be hard to handle for forward-chaining engines, depending on their implementation of the func:numeric-add builtin. In a backward-chaining strategy, the entailment should be found. The condition External(pred:numeric-greater-than(?x 0)) guarantees termination on backward-chaining, i.e. the rule only applies to positive numeric arguments. Chaining_strategy_numeric-add_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-add_2/Chaining_strategy_numeric-add_2-premise.rif ) Prefix(func ) Prefix(pred ) Group ( Forall ?x ( ex:a(?x) :- And ( ex:a(External(func:numeric-add(?x 1))) External(pred:numeric-greater-than(?x 0))) ) ex:a(10) ) ) ]]> Chaining_strategy_numeric-add_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-add_2/Chaining_strategy_numeric-add_2-conclusion.rif Approved BLD This test highlights the different behavior of forward-chaining vs. backward-chaining engines The entailment holds, but some engines may have difficulty finding it and/or may behave badly with it. This particular test case may be hard to handle for forward-chaining engines, depending on their implementation of the func:numeric-subtract builtin. In a backward-chaining strategy, the entailment should be found. Note that a backward-chaining engine, however, might have run into non-termination problems when the same ruleset is used to test conc=ex:a(0), since there is no termination condition in the body. Chaining_strategy_numeric-subtract_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-subtract_1/Chaining_strategy_numeric-subtract_1-premise.rif ) Prefix(func ) Group ( Forall ?x ( ex:a(?x) :- ex:a(External(func:numeric-subtract(?x 1))) ) ex:a(1) ) ) ]]> Chaining_strategy_numeric-subtract_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-subtract_1/Chaining_strategy_numeric-subtract_1-conclusion.rif Approved Core BLD PRD This test highlights the different behavior of forward-chaining vs. backward-chaining engines The entailment holds, but some engines may have difficulty finding it and/or may behave badly with it. This particular test case may be hard to handle for backward-chaining engines, depending on their implementation of the func:numeric-subtract builtin. In a forward-chaining strategy, the entailment should be found. Note that a backward-chaining engine, which is able to handle the external built-in in the head would avoid non-termination problems on arbitrary other entailment tests with this ruleset by the termination condition in the body. Chaining_strategy_numeric-subtract_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-subtract_2/Chaining_strategy_numeric-subtract_2-premise.rif ) Prefix(func ) Prefix(pred ) Group ( Forall ?x ( ex:a(External(func:numeric-subtract(?x 1))) :- And ( ex:a(?x) External(pred:numeric-greater-than-or-equal(?x 0))) ) ex:a(10) ) ) ]]> Chaining_strategy_numeric-subtract_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Chaining_strategy_numeric-subtract_2/Chaining_strategy_numeric-subtract_2-conclusion.rif Approved BLD Demonstrate and test behavior of frames and membership The conclusion is entailed from the premises by a separate rule which makes all property values of classes inherit to their instances. Note that this overly general rule is not an example of good modeling practice. Classification-inheritance-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Classification-inheritance/Classification-inheritance-premise.rif ) Prefix(ppl ) Prefix(cpt ) Group ( Forall ?C ?I ?P ?V ( ?I[?P -> ?V] :- And (?C[?P -> ?V] ?I#?C ) ) ppl:john#cpt:Person cpt:Person[tax:phylum -> tax:Chordata] ) ) ]]> Classification-inheritance-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Classification-inheritance/Classification-inheritance-conclusion.rif tax:Chordata] ]]> Approved BLD demonstrate and test behavior of frames and membership The conclusion is not entailed from the premises because RIF BLD does not postulate the inheritance of properties from classes to its members. Classification_non-inheritance-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Classification_non-inheritance/Classification_non-inheritance-premise.rif ) Prefix(ppl ) Prefix(cpt ) Group ( ppl:john#cpt:Person cpt:Person[tax:phylum -> tax:Chordata] ) ) ]]> Classification_non-inheritance-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Classification_non-inheritance/Classification_non-inheritance-nonconclusion.rif tax:Chordata] ]]> Approved BLD Test Case demonstrating class membership. This test cases defines a rule that represents an "isFatherOf" relation between male family members. It uses RIF class memberships to test if a family member is of the class "Male". Note that is not an example of Core syntax because of the membership facts. Class_Membership-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Class_Membership/Class_Membership-premise.rif ) Group ( Forall ?X ?Y ( fam:isFatherOf(?Y ?X) :- And (fam:isChildOf(?X ?Y) ?Y#fam:Male ) ) fam:isChildOf(fam:Adrian fam:Uwe) fam:Adrian#fam:Male fam:Uwe#fam:Male ) ) ]]> Class_Membership-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Class_Membership/Class_Membership-conclusion.rif Approved Core BLD PRD Test that safe formulas are accepted. Note that this ruleset does not have finite models, and is not strongly safe. Core_Safeness-input.rif http://www.w3.org/2005/rules/test/repository/tc/Core_Safeness/Core_Safeness-input.rif ) Prefix(func ) Group( ex:p(0) Forall ?x (ex:p(External(func:numeric-add(?x 1))) :- ex:p(?x)) ) ) ]]> Approved Core BLD PRD Test that safe formulas are accepted. The variables ?z and ?y are safe, because they are equated to ?x, which is safe. Core_Safeness_2-input.rif http://www.w3.org/2005/rules/test/repository/tc/Core_Safeness_2/Core_Safeness_2-input.rif ) Group( Forall ?x ?y ?z (ex:p(?z) :- And(ex:q(?x) ?x=?y ?y=?z)) ) ) ]]> Approved Core BLD PRD Test that safe formulas are accepted. The variable <tt>?x</tt> is unbound, but <tt>(u,b)</tt> is a valid binding pattern for <tt>pred:iri-string</tt>. Core_Safeness_3-input.rif http://www.w3.org/2005/rules/test/repository/tc/Core_Safeness_3/Core_Safeness_3-input.rif ) Prefix(pred ) Group( Forall ?x ?z (ex:p(?x) :- And( ex:q(?z) External(pred:iri-string(?x ?z)))) ) ) ]]> Approved Core BLD PRD This test shows a sample scenario related to exchanging electronic business contracts across rule platforms. The business rule captured is: if an item is perishable and it is delivered to a store more than ten days after the scheduled delivery date then the item will be rejected by the store EBusiness_Contract-premise.rif http://www.w3.org/2005/rules/test/repository/tc/EBusiness_Contract/EBusiness_Contract-premise.rif ) Prefix(cpt ) Prefix(ord ) Prefix(func ) Prefix(pred ) Prefix(xs ) Prefix(owl ) Prefix(dc ) Group ( (* _rule1[dc:name -> "rule 1" dc:publisher -> "http://www.w3.org/"^^rif:iri dc:date -> "2008-04-04Z"^^xs:date dc:description -> "if an item is perishable and it is delivered to a store more than ten days after the scheduled delivery date then the item will be rejected by the store" owl:versionInfo -> "0.1"^^xs:decimal] *) Forall ?item ?store ?deliverydate ?scheduledate ?diffduration ?diffdays ( cpt:reject(?store ?item) :- And(cpt:perishable(?item) cpt:delivered(?item ?deliverydate ?store) cpt:scheduled(?item ?scheduledate) External(pred:is-literal-dateTime(?deliverydate)) External(pred:is-literal-dateTime(?scheduledate)) ?diffduration = External(func:subtract-dateTimes(?deliverydate ?scheduledate)) ?diffdays = External(func:days-from-duration(?diffduration)) External(pred:numeric-greater-than(?diffdays 10))) ) cpt:perishable(ord:Order14) cpt:delivered(ord:Order14 "2008-07-22Z"^^xs:date stores:Store9) cpt:scheduled(ord:Order14 "2008-07-11Z"^^xs:date) ) ) ]]> EBusiness_Contract-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/EBusiness_Contract/EBusiness_Contract-conclusion.rif ( ) ]]> Approved BLD Test equality between lists Equality of elements is derived from equality of lists. ElementEqualityFromListEquality-premise.rif http://www.w3.org/2005/rules/test/repository/tc/ElementEqualityFromListEquality/ElementEqualityFromListEquality-premise.rif ) Group( List(ex:a) = List(ex:b) ) ) ]]> ElementEqualityFromListEquality-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/ElementEqualityFromListEquality/ElementEqualityFromListEquality-conclusion.rif Approved BLD Test that arbitrary Consts are entailed EntailEverything-premise.rif http://www.w3.org/2005/rules/test/repository/tc/EntailEverything/EntailEverything-premise.rif ) Group ( Forall ?x ( ex:A(?x) ) ) ) ]]> EntailEverything-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/EntailEverything/EntailEverything-conclusion.rif ) ) ]]> Approved BLD Test use of equality in a rule conclusion The rule in this test case says that there is a functional relationship between the first and the second argument of the predicate p. In other words, if x is related to y by p and x is related to z by p, then y and z must be the same thing. This makes p equivalent to a functional property in OWL. Equality_in_conclusion_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_1/Equality_in_conclusion_1-premise.rif ) Group ( Forall ?x ?y ?z ( ?y=?z :- And ( ex:p(?x ?y) ex:p(?x ?z) ) ) ex:p(ex:a ex:b) ex:p(ex:a ex:c) ) ) ]]> Equality_in_conclusion_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_1/Equality_in_conclusion_1-conclusion.rif Approved BLD Test use of equality in a rule conclusion This rules says that if x is a home worker, then x's home zip code is the same as x's work zip code. In general, a rule of this form can be used to express that if x is of a certain class then two different logical functions must have the same interpretation when applied to x. Equality_in_conclusion_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_2/Equality_in_conclusion_2-premise.rif ) Group ( Forall ?x ( ex:workZIPCode(?x) = ex:homeZIPCode(?x) :- ex:homeWorker(?x) ) ex:homeWorker(ex:a) ) ) ]]> Equality_in_conclusion_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_2/Equality_in_conclusion_2-conclusion.rif Approved BLD Test substitutivity in the context of equality. This test case verifies that the substitutivity axiom for equality is implemented. In particular, it checks that substitutivity applies to terms nested deeply inside other terms. In this test case, g(c) must be substituted by f(b) at nesting levels 1 and 2 in order for the test to check out. Substitutivity is hard to implement properly and efficiently. Equality_in_conclusion_3-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_3/Equality_in_conclusion_3-premise.rif ) Group ( Forall ?x ?y ?z ( ex:f(?y)=ex:g(?z) :- And ( ex:p(?x ?y) ex:p(?x ?z) ) ) ex:p(ex:a ex:b) ex:p(ex:a ex:c) ex:q(ex:h(ex:g(ex:c))) ) ) ]]> Equality_in_conclusion_3-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_conclusion_3/Equality_in_conclusion_3-conclusion.rif Approved BLD Demonstrate equational use of equality Define a predicate to be true when x^3-x=0 Equality_in_condition-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_condition/Equality_in_condition-premise.rif ) Prefix(func ) Prefix(pred ) Prefix(xs ) Group( Forall ?x ( ex:root(?x) :- And (External(pred:is-literal-decimal(?x)) External(func:numeric-subtract(External(func:numeric-multiply(?x External(func:numeric-multiply(?x ?x)))) ?x)) = "0"^^xs:decimal ) ) ) ) ]]> Equality_in_condition-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Equality_in_condition/Equality_in_condition-conclusion.rif Approved Core BLD PRD express factorial using Core This version of factorial is safe, and thus can be implemented by a forward chaining Core or PRD reasoner. Note the difference from [[Factorial Relational]] -- the variable ?N is computed from ?N1 rather than the other way around. Factorial_Forward_Chaining-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Forward_Chaining/Factorial_Forward_Chaining-premise.rif ) Prefix(func ) Prefix(ex ) Group ( ex:factorial(0 1) Forall ?N ?F ?N1 ?F1 ( ex:factorial(?N ?F) :- And(External(pred:numeric-greater-than-or-equal(?N1 0)) ?N = External(func:numeric-add(?N1 1)) ex:factorial(?N1 ?F1) ?F = External(func:numeric-multiply(?N ?F1)) ) ) ) ) ]]> Factorial_Forward_Chaining-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Forward_Chaining/Factorial_Forward_Chaining-conclusion.rif Approved BLD test ground equational call to factorial function Factorial function using equality in the head to have function return value. This test case also demonstrates recursion and the use of mathematical built-in predicates and functions corresponding to >, -, and *. Factorial_Functional-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Functional/Factorial_Functional-premise.rif ) Prefix(func ) Prefix(ex ) Group ( ex:factorial(0) = 1 Forall ?N ( ex:factorial(?N) = External(func:numeric-multiply( ?N ex:factorial(External(func:numeric-subtract(?N 1))))) :- External(pred:numeric-greater-than(?N 0)) ) ) ) ]]> Factorial_Functional-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Functional/Factorial_Functional-conclusion.rif Approved BLD test ground call to factorial predicate Factorial predicate using equality to assign computed values to variables. This test case also demonstrates recursion and the use of mathematical built-in predicates and functions corresponding to >, -, and *. Factorial_Relational-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Relational/Factorial_Relational-premise.rif ) Prefix(func ) Prefix(ex ) Group ( ex:factorial(0 1) Forall ?N ?F ?N1 ?F1 ( ex:factorial(?N ?F) :- And(External(pred:numeric-greater-than(?N 0)) ?N1 = External(func:numeric-subtract(?N 1)) ex:factorial(?N1 ?F1) ?F = External(func:numeric-multiply(?N ?F1)) ) ) ) ) ]]> Factorial_Relational-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Factorial_Relational/Factorial_Relational-conclusion.rif Approved Core BLD PRD To demonstrate different syntactic options for specifying arguments This test case demonstrates the same use case as "named arguments" and "positional arguments" using frames instead of named or positional arguments. Frames-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Frames/Frames-premise.rif ) Prefix(xs ) Group ( Forall ?Customer ( ?Customer[ex:discount -> 10] :- ?Customer[ex:status -> "gold"] ) Forall ?Customer ( ?Customer[ex:discount -> 5] :- ?Customer[ex:status -> "silver"] ) ex:customer017[ex:status -> "gold" ex:name -> "John Doe"] ) ) ]]> Frames-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Frames/Frames-conclusion.rif 10 ex:name -> "John Doe"] ]]> Approved Core BLD PRD Illustrate difference between frames and named-argument uniterms Frames are essentially syntactic sugar for an open set of binary predicates. Frame_slots_are_independent-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Frame_slots_are_independent/Frame_slots_are_independent-premise.rif ) Group ( ex:o[ex:a->1 ex:b->2] ) ) ]]> Frame_slots_are_independent-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Frame_slots_are_independent/Frame_slots_are_independent-conclusion.rif 1] ]]> Approved Core BLD PRD Demonstrate subtype relationships between xs:decimal and xs:integer Since xs:integer is a subtype of xs:decimal then "3"^^xs:decimal and "3"xs:integer are the same value and pass both integer and decimal guards Guards_and_subtypes-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Guards_and_subtypes/Guards_and_subtypes-premise.rif ) Prefix(pred ) Prefix(xs ) Group( ex:p("pass 1") :- External(pred:is-literal-decimal("3"^^xs:integer)) ex:p("pass 2") :- External(pred:is-literal-integer("3"^^xs:decimal)) ) ) ]]> Guards_and_subtypes-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Guards_and_subtypes/Guards_and_subtypes-conclusion.rif Approved BLD Test for inconsistent entailment The fact "a"="b" is inconsistent, i.e., it has no model, because the strings "a" and "b" are known to be different, by the XML schema specification. Any formula is entailed by an inconsistent rule set, including this particular conclusion, which states that there exists an object that is both an integer and not an integer. Inconsistent_Entailment-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Inconsistent_Entailment/Inconsistent_Entailment-premise.rif Inconsistent_Entailment-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Inconsistent_Entailment/Inconsistent_Entailment-conclusion.rif (?x)) External((?x)) ) ) ]]> Approved BLD http://www.w3.org/ns/entailment/OWL-Direct Test that violation of separation of the individual and data value domains leads to inconsistency The rule requires every element, including every concrete data value, to be a member of the class ex:A. However, OWL-Direct semantics requires every member of ex:A to not be a concrete data value. Therefore, the combination is inconsistent, and an inconsistent condition formula can be derived. Individual-Data_Separation_Inconsistency-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/Individual-Data_Separation_Inconsistency/Individual-Data_Separation_Inconsistency-import001 . @prefix rdf: . @prefix rdfs: . @prefix owl: . _:o rdf:type owl:Ontology . ex:A rdfs:subClassOf ex:B . ]]> Individual-Data_Separation_Inconsistency-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Individual-Data_Separation_Inconsistency/Individual-Data_Separation_Inconsistency-premise.rif ) Prefix(ex ) Import( ) Group ( Forall ?x (?x[rdf:type -> ex:A]) ) ) ]]> Individual-Data_Separation_Inconsistency-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Individual-Data_Separation_Inconsistency/Individual-Data_Separation_Inconsistency-conclusion.rif Approved BLD Demonstrate that a single IRI may correspond to itself The built-in predicate <tt>pred:iri-string</tt> is satisfied whenever the second argument is a string corresponding to representing the first argument. As IRI constants may be interpreted as arbitrary objects, they may be interpreted as strings as well. In this case, the IRI constant <tt>ex:a</tt> and the string <tt>"http://example.com/example#a"</tt> are equal, and so <tt>ex:a</tt> corresponds to itself. IRI_from_IRI-premise.rif http://www.w3.org/2005/rules/test/repository/tc/IRI_from_IRI/IRI_from_IRI-premise.rif ) Prefix(pred ) Group( ex:a="http://example.org/example#a" ) ) ]]> IRI_from_IRI-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/IRI_from_IRI/IRI_from_IRI-conclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test extracting IRIs from RDF plain literals A plain literal in RDF is seen as a string in RIF-RDF combinations, and therefore it is possible to "extract" IRI constants from such literals using the <tt>pred:iri-string</tt> built-in predicate. IRI_from_RDF_Literal-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/IRI_from_RDF_Literal/IRI_from_RDF_Literal-import001 "http://www.example.org/" . ]]> IRI_from_RDF_Literal-premise.rif http://www.w3.org/2005/rules/test/repository/tc/IRI_from_RDF_Literal/IRI_from_RDF_Literal-premise.rif ) Prefix(pred ) Prefix(foaf ) Import( ) Group ( Forall ?x ?y ?z (?y[foaf:homepage -> ?z] :- And( ?y[ex:hasWebSite -> ?x] External(pred:iri-string(?z ?x)) ) ) ) ) ]]> IRI_from_RDF_Literal-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/IRI_from_RDF_Literal/IRI_from_RDF_Literal-conclusion.rif "http://www.example.org/"^^rif:iri]) ]]> Approved BLD Test equality between lists and constants IRIs may be mapped to arbitrary elements in the domain, and so also to elements representing lists. ListConstantEquality-premise.rif http://www.w3.org/2005/rules/test/repository/tc/ListConstantEquality/ListConstantEquality-premise.rif ) Group( ex:a=List(ex:b ex:c) ex:p(ex:a) ) ) ]]> ListConstantEquality-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/ListConstantEquality/ListConstantEquality-conclusion.rif Approved BLD Test equality between lists Equality of lists is derived from equality of elements. ListEqualityFromElementEquality-premise.rif http://www.w3.org/2005/rules/test/repository/tc/ListEqualityFromElementEquality/ListEqualityFromElementEquality-premise.rif ) Group( ex:a=ex:b ) ) ]]> ListEqualityFromElementEquality-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/ListEqualityFromElementEquality/ListEqualityFromElementEquality-conclusion.rif Approved BLD Test equality between lists and constants representing data values Lists are mapped to elements in the domain that are not data values, and so assertion of equality between a data value and a list is inconsistent, and entails falsehood (written as Or() in RIF). ListLiteralEquality-premise.rif http://www.w3.org/2005/rules/test/repository/tc/ListLiteralEquality/ListLiteralEquality-premise.rif ) Group( "a"=List(ex:b) ) ) ]]> ListLiteralEquality-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/ListLiteralEquality/ListLiteralEquality-conclusion.rif Approved Core BLD PRD Test that the entailment relation does not preserve names of local constants The labels of local constants are local to the specific document in which they occur. Therefore, these labels are not visible outside the documents. In particular, local constants in the entailed formulas should be considered distinct from those in the entailing document, even if the labels coincide. Local_Constant-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Local_Constant/Local_Constant-premise.rif ("a"^^rif:local)) ) ]]> Local_Constant-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Local_Constant/Local_Constant-nonconclusion.rif ("a"^^rif:local) ]]> Approved Core BLD PRD Test that the entailment relation does not preserve names of local predicates The entailment relation does not preserve labels of local constants, neither when they are used as [[Local Constant|individuals]], nor when they are used as predicates (as in this case). Local_Predicate-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Local_Predicate/Local_Predicate-premise.rif )) ) ]]> Local_Predicate-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Local_Predicate/Local_Predicate-nonconclusion.rif ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct A simplified example of RIF-Core rules combined with OWL to capture anatomical knowledge that can be used to help label brain cortex structures in MRI images. This highly simplified ontology and rule base gives the flavor of a system that could be used to identify brain cortex structures in MRI images. The ontology represents the main entities and properties of the brain, and the rule base specifies relationships between ontology properties. In this example, the rule says that two entities are connected when they have a common boundary. In a full usage example, the inferred fact in this case could be combined with other facts to identify g1 as an e.g. preCentralGyrus. Modeling_Brain_Anatomy-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/Modeling_Brain_Anatomy/Modeling_Brain_Anatomy-import001.rdf ) Ontology( SubClassOf(MaterialAnatomicalEntity AnatomicalEntity) SubClassOf(Gyrus MaterialAnatomicalEntity) SubClassOf(NonMaterialAnatomicalEntity AnatomicalEntity) SubClassOf(GyriConnection NonMaterialAnatomicalEntity) SubClassOf(SucalFold NonMaterialAnatomicalEntity) SymmetricObjectProperty(isMAEConnectedTo) ObjectPropertyDomain(isMAEConnectedTo MaterialAnatomicalEntity) ObjectPropertyRange(isMAEConnectedTo MaterialAnatomicalEntity) ObjectPropertyDomain(isMAEBoundedBy MaterialAnatomicalEntity) ObjectPropertyRange(isMAEBoundedBy ObjectUnionOf(SucalFold GyriConnection)) Declaration(Individual(g1)) ClassAssertion(g1 Gyrus) ObjectPropertyAssertion(isMAEBoundedBy g1 op) Declaration(Individual(pcg0)) ClassAssertion(pcg0 Gyrus) ObjectPropertyAssertion(isMAEBoundedBy pcg0 op) Declaration(Individual(op)) ClassAssertion(op GyriConnection) ) ]]> Modeling_Brain_Anatomy-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Modeling_Brain_Anatomy/Modeling_Brain_Anatomy-premise.rif ) Prefix(rdf ) Prefix(dc ) Import( ) Group ( (* _rule1[dc:description -> "entities that are bounded by a common gyri connection are connected to each other"] *) Forall ?X ?Y ?Z ( ?X [ba:isMAEConnectedTo -> ?Y] :- And (?X[ba:isMAEBoundedBy -> ?Z] ?Y[ba:isMAEBoundedBy -> ?Z] ?X[rdf:type -> ba:MaterialAnatomicalEntity] ?Y[rdf:type -> ba:MaterialAnatomicalEntity] ?Z[rdf:type -> ba:GyriConnection]) ) ) ) ]]> Modeling_Brain_Anatomy-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Modeling_Brain_Anatomy/Modeling_Brain_Anatomy-conclusion.rif ba:pcg0] ]]> Approved Core BLD PRD A constant symbol that is not a rif:local constant cannot occur in more than one context in the imports closure of a RIF document. The constant symbol eg:discount is used as a predicate in the importing document and as an individual in the imported document. Multiple_Context_Error-import001.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_Context_Error/Multiple_Context_Error-import001.rif ) Prefix(xs ) Group ( Forall ?Name ( eg:customer[eg:discount -> "10"^^xs:integer eg:name -> ?Name] :- eg:customer[eg:status -> "gold" eg:name -> ?Name] ) ) ) ]]> Multiple_Context_Error-input.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_Context_Error/Multiple_Context_Error-input.rif ) Prefix(xs ) Import() Group ( Forall ?Customer ( eg:discount(?Customer "5"^^xs:integer) :- eg:silver(?Customer) ) ) ) ]]> Approved BLD Demonstrate that a single string may correspond to several IRIs The built-in predicate <tt>pred:iri-string</tt> is satisfied whenever the second argument is a string corresponding to and IRI representing the first argument. A single string may correspond to multiple IRI constants. In this case, the IRI constants ex:a and ex:b are equal, and so either constant corresponds to either string representation. In particular, <tt>"http://example.com/example#a"</tt> is a string representation for both <tt>"http://example.com/example#a"^^rif:iri</tt> and <tt>"http://example.com/example#b"^^rif:iri</tt>. Multiple_IRIs_from_String-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_IRIs_from_String/Multiple_IRIs_from_String-premise.rif ) Prefix(pred ) Group( ex:a=ex:b ) ) ]]> Multiple_IRIs_from_String-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_IRIs_from_String/Multiple_IRIs_from_String-conclusion.rif Approved BLD Demonstrate that a single IRI may correspond to several strings The built-in predicate <tt>pred:iri-string</tt> is satisfied whenever the second argument is a string corresponding to representing the first argument. There may be several strings corresponding to a single IRI constant. In this case, the IRI constants ex:a and ex:b are equal, and so either constant corresponds to either string representation. In particular, both <tt>"http://example.com/example#a"</tt> and <tt>"http://example.com/example#b"</tt> are string representations for the constant <tt>"http://example.com/example#a"^^rif:iri</tt>. Multiple_Strings_from_IRI-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_Strings_from_IRI/Multiple_Strings_from_IRI-premise.rif ) Prefix(pred ) Group( ex:a=ex:b ) ) ]]> Multiple_Strings_from_IRI-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Multiple_Strings_from_IRI/Multiple_Strings_from_IRI-conclusion.rif Approved BLD To demonstrate different syntactic options for specifying arguments This test case demonstrates the same use case as "positional arguments" and "frames" using named arguments instead of positional arguments or frames. Named_Arguments-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Named_Arguments/Named_Arguments-premise.rif ) Prefix(xs ) Group ( Forall ?Customer ( ex:discount(value -> 10 customer -> ?Customer) :- ex:gold(customer -> ?Customer) ) Forall ?Customer ( ex:discount(customer -> ?Customer value -> 5) :- ex:silver(customer -> ?Customer) ) ex:gold(customer -> "John Doe") ) ) ]]> Named_Arguments-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Named_Arguments/Named_Arguments-conclusion.rif "John Doe" value -> 10) ]]> Approved BLD Illustrate difference between frames and named-argument uniterms Named argument uniterms with the same predicate symbol but different arities represent distinct predicates and so pattern p(a->?) will not match a fact p(a->foo,b->bar), whereas Frames are essentially syntactic sugar for an open set of binary predicates and so such partial patterns do match. Named_Argument_Uniterms_non-polymorphic-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Named_Argument_Uniterms_non-polymorphic/Named_Argument_Uniterms_non-polymorphic-premise.rif ) Group ( ex:p(a->1 b->2) ) ) ]]> Named_Argument_Uniterms_non-polymorphic-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Named_Argument_Uniterms_non-polymorphic/Named_Argument_Uniterms_non-polymorphic-nonconclusion.rif 1) ]]> Approved Core BLD PRD Nested lists are not flat lists NestedListsAreNotFlatLists-premise.rif http://www.w3.org/2005/rules/test/repository/tc/NestedListsAreNotFlatLists/NestedListsAreNotFlatLists-premise.rif ) Group( ex:p(List(ex:a List(ex:b))) ) ) ]]> NestedListsAreNotFlatLists-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/NestedListsAreNotFlatLists/NestedListsAreNotFlatLists-nonconclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct Test that annotation properties are discarded when considering OWL-Direct entailment When using the OWL-Direct profile for importing ontologies, annotation properties must be discarded, and do not affect the rules or the conclusions that may be drawn from the ruleset. Non-Annotation_Entailment-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/Non-Annotation_Entailment/Non-Annotation_Entailment-import001 . @prefix rdf: . @prefix owl: . @prefix dc: . ex:myOnto rdf:type owl:Ontology . ex:myOnto dc:title "Example ontology" . dc:title rdf:type owl:OntologyProperty . ]]> Non-Annotation_Entailment-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Non-Annotation_Entailment/Non-Annotation_Entailment-premise.rif ) Prefix(dc ) Import( ) Group ( Forall ?x ?y ( ?x[ex:hasTitle -> ?y] :- ?x[dc:title -> ?y]) ) ) ]]> Non-Annotation_Entailment-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Non-Annotation_Entailment/Non-Annotation_Entailment-nonconclusion.rif "Example ontology"] ]]> Approved BLD PRD Core All free variables in the rule must be quantified with Forall The variable "price" is not included in the variable list of the Forall <!-- desc=on hold pending resolution of http://lists.w3.org/Archives/Public/public-rif-wg/2008Sep/0013.html--> No_free_variables-input.rif http://www.w3.org/2005/rules/test/repository/tc/No_free_variables/No_free_variables-input.rif ) Group ( Forall ?buyer ?item ?seller ( eg:Buy(?buyer ?item ?seller) :- eg:Sell(?seller ?item ?buyer ?price) ) ) ) ]]> Approved BLD Show that general open lists are valid structures (although some might call them malformed, they are not forbidden). "General Open Lists" (where the tail is not a list, that is, like LISP dotted pairs) are technically lists in BLD, although they don't necessarily behave like normal lists. They are not a syntax error, and are not a logic error. OpenLists-premise.rif http://www.w3.org/2005/rules/test/repository/tc/OpenLists/OpenLists-premise.rif ) Group( ex:p(List(ex:a | "b")) ) ) ]]> OpenLists-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/OpenLists/OpenLists-nonconclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct Test that an invalid combination is rejected If a RIF document R imports only documents with OWL-Direct profiles and R is not a DL-document formula, then R must be rejected. The frame formula in the RIF document is not a DL-Frame formula because it has a variable in the property position, and so the document is not a DL-document formula. OWL_Combination_Invalid_DL_Formula-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Invalid_DL_Formula/OWL_Combination_Invalid_DL_Formula-import001 . @prefix owl: . _:x rdf:type owl:Ontology . ]]> OWL_Combination_Invalid_DL_Formula-input.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Invalid_DL_Formula/OWL_Combination_Invalid_DL_Formula-input.rif ) Group ( Forall ?x ( (?x) :- [?x -> "17"^^xs:integer] ) ) ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct Test that an invalid combination is rejected If a RIF document R imports OWL ontologies using the OWL-Direct profile that are not OWL 2 DL ontologies, then R must be rejected. The imported ontology is not an OWL 2 DL ontology (because it is the empty graph), and so R must be rejected. OWL_Combination_Invalid_DL_Import-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Invalid_DL_Import/OWL_Combination_Invalid_DL_Import-import001 OWL_Combination_Invalid_DL_Import-input.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Invalid_DL_Import/OWL_Combination_Invalid_DL_Import-input.rif ) Group ( ) ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct Test that violation of separation of the (individual and data value) vocabulary leads to inconsistency The same constant cannot be both an individual and a data value; this leads to inconsistency, and thus "a"="b" is entailed. OWL_Combination_Vocabulary_Separation_Inconsistency_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_1/OWL_Combination_Vocabulary_Separation_Inconsistency_1-import001 . @prefix rdf: . @prefix owl: . _:o rdf:type owl:Ontology . ex:myiri rdf:type ex:A . ]]> OWL_Combination_Vocabulary_Separation_Inconsistency_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_1/OWL_Combination_Vocabulary_Separation_Inconsistency_1-premise.rif ) Prefix(xs ) Prefix(rdf ) Import( ) Group ( ex:myiri[rdf:type -> xs:string] ) ) ]]> OWL_Combination_Vocabulary_Separation_Inconsistency_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_1/OWL_Combination_Vocabulary_Separation_Inconsistency_1-conclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/OWL-Direct Test that violation of separation of the (object and datatype value property) vocabulary leads to inconsistency The same property cannot have both individuals and data values in its range. In particular, since ex:hasChild is an owl:ObjectProperty, there may be no concrete data values (e.g., strings) in its range. Since in this case, there is a data value ("John") in its range, the combination is inconsistent, and an inconsistent atom ("a"="b") is derived. OWL_Combination_Vocabulary_Separation_Inconsistency_2-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_2/OWL_Combination_Vocabulary_Separation_Inconsistency_2-import001 . @prefix rdf: . @prefix owl: . _:o rdf:type owl:Ontology . ex:hasChild rdf:type owl:ObjectProperty . ]]> OWL_Combination_Vocabulary_Separation_Inconsistency_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_2/OWL_Combination_Vocabulary_Separation_Inconsistency_2-premise.rif ) Import( ) Group ( ex:myiri[ex:hasChild -> "John"] ) ) ]]> OWL_Combination_Vocabulary_Separation_Inconsistency_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/OWL_Combination_Vocabulary_Separation_Inconsistency_2/OWL_Combination_Vocabulary_Separation_Inconsistency_2-conclusion.rif Approved Core BLD PRD To demonstrate different syntactic options for specifying arguments This test case demonstrates the same use case as "named arguments" and "frames" using ordered (positional) arguments instead of named arguments or frames. Positional_Arguments-premise.rif http://www.w3.org/2005/rules/test/repository/tc/Positional_Arguments/Positional_Arguments-premise.rif ) Prefix(xs ) Group ( Forall ?Customer ( ex:discount(?Customer 10) :- ex:gold(?Customer) ) Forall ?Customer ( ex:discount(?Customer 5) :- ex:silver(?Customer) ) ex:gold("John Doe") ) ) ]]> Positional_Arguments-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/Positional_Arguments/Positional_Arguments-conclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/RDF Test interaction between RDF and BLD with respect to blank nodes Blank nodes cannot be referenced directly from a RIF rule because they are local to a specific RDF graph. However, variables do range over objects denoted by blank nodes, so it is possible to "access" an object denoted by a blank node from a RIF rule by using a variable. RDF_Combination_Blank_Node-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Blank_Node/RDF_Combination_Blank_Node-import001 "John" . ]]> RDF_Combination_Blank_Node-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Blank_Node/RDF_Combination_Blank_Node-premise.rif ) Prefix(rdf ) Import( ) Group ( Forall ?x ?y ( ?x[rdf:type -> ex:named] :- ?x[ex:hasName -> ?y] ) ) ) ]]> RDF_Combination_Blank_Node-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Blank_Node/RDF_Combination_Blank_Node-conclusion.rif ] ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test equivalent treatment of RDF constants and RIF symbols in simple entailment The syntax for constants in RIF and RDF is slightly different; RDF has a number of different kinds of constants (e.g., IRI, in a literal, typed literal), whereas RIF has a single kind of constant (i.e., a pair <literal, symbol space>). As a consequence, in RIF-RDF combinations, an IRI in RDF is equivalent to a literal with type rif:iri in RIF. RDF_Combination_Constant_Equivalence_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_1/RDF_Combination_Constant_Equivalence_1-import001 . ]]> RDF_Combination_Constant_Equivalence_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_1/RDF_Combination_Constant_Equivalence_1-premise.rif ) ) ]]> RDF_Combination_Constant_Equivalence_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_1/RDF_Combination_Constant_Equivalence_1-conclusion.rif [ -> ] ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test equivalent treatment of RDF constants and RIF symbols in simple entailment The syntax for constants in RIF and RDF is slightly different; RDF has a number of different kinds of constants (e.g., IRI, in a literal, typed literal), whereas RIF has a single kind of constant (i.e., a pair <literal, symbol space>). In particular, in combinations, there is no distinction between plain literals and literals with type xs:string. RDF_Combination_Constant_Equivalence_2-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_2/RDF_Combination_Constant_Equivalence_2-import001 "this is a plain literal" . ]]> RDF_Combination_Constant_Equivalence_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_2/RDF_Combination_Constant_Equivalence_2-premise.rif ) ) ]]> RDF_Combination_Constant_Equivalence_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_2/RDF_Combination_Constant_Equivalence_2-conclusion.rif [ -> "this is a plain literal"] ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test equivalent treatment of RDF constants and RIF symbols in simple entailment The syntax for constants in RIF and RDF is slightly different; RDF has a number of different kinds of constants (e.g., IRI, in a literal, typed literal), whereas RIF has a single kind of constant (i.e., a pair <literal, symbol space>). As a consequence, in RIF-RDF combinations, a plain literal with a language tag in RDF is equivalent to a literal of type rdf:plainLiteral in RIF. RDF_Combination_Constant_Equivalence_3-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_3/RDF_Combination_Constant_Equivalence_3-import001 "with language tag"@en . ]]> RDF_Combination_Constant_Equivalence_3-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_3/RDF_Combination_Constant_Equivalence_3-premise.rif ) ) ]]> RDF_Combination_Constant_Equivalence_3-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_3/RDF_Combination_Constant_Equivalence_3-conclusion.rif [ -> "with language tag@en"^^rdf:PlainLiteral] ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test equivalent treatment of RDF constants and RIF symbols in simple entailment The syntax for constants in RIF and RDF is slightly different; RDF has a number of different kinds of constants (e.g., IRI, in a literal, typed literal), whereas RIF has a single kind of constant (i.e., a pair <literal, symbol space>). In particular, in combinations, there is no distinction between plain literals and literals with type xs:string. RDF_Combination_Constant_Equivalence_4-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_4/RDF_Combination_Constant_Equivalence_4-import001 . "this is a string"^^xs:string . ]]> RDF_Combination_Constant_Equivalence_4-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_4/RDF_Combination_Constant_Equivalence_4-premise.rif ) ) ]]> RDF_Combination_Constant_Equivalence_4-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_4/RDF_Combination_Constant_Equivalence_4-conclusion.rif [ -> "this is a string"] ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test equivalent treatment of RDF constants and RIF symbols in simple entailment The syntax for constants in RIF and RDF is slightly different; RDF has a number of different kinds of constants (e.g., IRI, in a literal, typed literal), whereas RIF has a single kind of constants (i.e., pairs <literal, symbol space>). In particular, in combinations, there is no distinction between plain literals and literals with type xs:string. RDF_Combination_Constant_Equivalence_Graph_Entailment-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_Graph_Entailment/RDF_Combination_Constant_Equivalence_Graph_Entailment-import001 . @prefix xs: . @prefix rif: . ex:a ex:p "this is a plain literal" . ]]> RDF_Combination_Constant_Equivalence_Graph_Entailment-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_Graph_Entailment/RDF_Combination_Constant_Equivalence_Graph_Entailment-premise.rif ) ) ]]> RDF_Combination_Constant_Equivalence_Graph_Entailment-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Constant_Equivalence_Graph_Entailment/RDF_Combination_Constant_Equivalence_Graph_Entailment-conclusion.rif . @prefix xs: . ex:a ex:p "this is a plain literal"^^xs:string . ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Verify that rif:iri typed literals are not allowed in RDF graphs imported by RIF documents RDF_Combination_Invalid_Constant_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Constant_1/RDF_Combination_Invalid_Constant_1-import001 . @prefix rif: . ex:a ex:p "http://example.org/#b"^^rif:iri . ]]> RDF_Combination_Invalid_Constant_1-input.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Constant_1/RDF_Combination_Invalid_Constant_1-input.rif ) ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Verify that rdf:PlainLiteral typed literals are not allowed in RDF graphs imported by RIF documents RDF_Combination_Invalid_Constant_2-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Constant_2/RDF_Combination_Invalid_Constant_2-import001 . @prefix rdf: . ex:a ex:p "with language tag@en"^^rdf:PlainLiteral . ]]> RDF_Combination_Invalid_Constant_2-input.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Constant_2/RDF_Combination_Invalid_Constant_2-input.rif ) ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple http://www.w3.org/ns/entailment/OWL-Direct Test that a RIF document with an invalid set of import directives is rejected There must be a highest profile in the set of profiles specified in a RIF document's import closure. There is no ordering defined between the Simple and OWL-Direct profiles, and so no highest profile. See SpecRef. RDF_Combination_Invalid_Profiles_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Profiles_1/RDF_Combination_Invalid_Profiles_1-import001 RDF_Combination_Invalid_Profiles_1-import002.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Profiles_1/RDF_Combination_Invalid_Profiles_1-import002 RDF_Combination_Invalid_Profiles_1-input.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Invalid_Profiles_1/RDF_Combination_Invalid_Profiles_1-input.rif ) Import( ) ) ]]> Approved BLD http://www.w3.org/ns/entailment/Simple test relationships between #/## and rdf:type/rdfs:subClassOf Declaring i to be rdf:type A leads to i#A since rdf:type and # are equivalent. Conversely declaring k#A leads to the frame corresponding to the triple: k rdf:type A. Declaring A##B leads to A rdfs:subClassOf B since rdfs:subClassOf is a super-property of ##, and so to i rdf:type B. RDF_Combination_Member_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Member_1/RDF_Combination_Member_1-import001 . ]]> RDF_Combination_Member_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Member_1/RDF_Combination_Member_1-premise.rif ) Import( ) Group ( ex:A ## ex:B ex:k # ex:A ) ) ]]> RDF_Combination_Member_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_Member_1/RDF_Combination_Member_1-conclusion.rif ex:A] ex:A[rdfs:subClassOf->ex:B] ex:i # ex:B ex:i[rdf:type->ex:B] ) ]]> Approved Core BLD PRD http://www.w3.org/ns/entailment/Simple Test interaction between rdfs:subClassOf, rdf:type, ## and # in RIF In RIF-RDF combinations, we have that rdf:type statements are equivalent to RIF # statements and RIF ## statements imply rdfs:subClassOf statements. By the semantics of combinations, we have that ex:a rdf:type ex:C implies ex:a # ex:C, but ex:C rdfs:subClassOf ex:D does not imply ex:C ## ex:D. Therefore, ex:a # ex:D cannot be derived. Notice that the import profile is 'Simple'. RDF_Combination_SubClass-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass/RDF_Combination_SubClass-import001 . @prefix rdfs: . @prefix rdf: . ex:a rdf:type ex:C . ex:C rdfs:subClassOf ex:D . ]]> RDF_Combination_SubClass-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass/RDF_Combination_SubClass-premise.rif ) ) ]]> RDF_Combination_SubClass-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass/RDF_Combination_SubClass-nonconclusion.rif Approved Core BLD PRD http://www.w3.org/ns/entailment/RDFS Test interaction between rdfs:subClassOf, rdf:type, ## and # in RIF In RIF-RDF combinations, we have that rdf:type statements are equivalent to RIF # statements and RIF ## statements imply rdfs:subClassOf statements. By the RDFS semantics we have that ex:a rdf:type ex:D must hold and by the semantics of combinations, we have that ex:a rdf:type ex:D implies ex:a # ex:D. Therefore, ex:a # ex:D is derived. RDF_Combination_SubClass_2-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_2/RDF_Combination_SubClass_2-import001 . @prefix rdfs: . @prefix rdf: . ex:a rdf:type ex:C . ex:C rdfs:subClassOf ex:D . ]]> RDF_Combination_SubClass_2-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_2/RDF_Combination_SubClass_2-premise.rif ) ) ]]> RDF_Combination_SubClass_2-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_2/RDF_Combination_SubClass_2-conclusion.rif Approved BLD http://www.w3.org/ns/entailment/Simple Test interaction between rdfs:subClassOf and ## statements in RIF In RIF-RDF combinations, we have that RIF ## statements imply rdfs:subClassOf statements. So, ex:a[rdfs:subClassOf -> ex:b] follows from ex:a ## ex:b. However, ## is not reflexive, and so ex:a[rdfs:subClassOf -> ex:a] is not implied. Notice that the simple profile is used. RDF_Combination_SubClass_3-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_3/RDF_Combination_SubClass_3-import001 RDF_Combination_SubClass_3-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_3/RDF_Combination_SubClass_3-premise.rif ) Prefix(rdfs ) Import( ) Group ( ex:a ## ex:b ) ) ]]> RDF_Combination_SubClass_3-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_3/RDF_Combination_SubClass_3-nonconclusion.rif ex:a] ]]> Approved BLD http://www.w3.org/ns/entailment/RDFS Test interaction between rdfs:subClassOf and ## statements in RIF In RIF-RDF combinations, we have that RIF ## statements imply rdfs:subClassOf statements. So, ex:a[rdfs:subClassOf -> ex:b] follows from ex:a ## ex:b. Under RDFS semantics, rdfs:subClassOf is reflexive, so ex:a[rdfs:subClassOf -> ex:a] is implied. RDF_Combination_SubClass_4-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_4/RDF_Combination_SubClass_4-import001 RDF_Combination_SubClass_4-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_4/RDF_Combination_SubClass_4-premise.rif ) Prefix(rdfs ) Import( ) Group ( ex:a ## ex:b ) ) ]]> RDF_Combination_SubClass_4-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_4/RDF_Combination_SubClass_4-conclusion.rif ex:a] ]]> Approved BLD PRD http://www.w3.org/ns/entailment/Simple Test interaction between rdfs:subClassOf and ## statements in RIF In RIF-RDF combinations, we have that RIF ## statements imply rdfs:subClassOf statements, but not vice versa. RDF_Combination_SubClass_5-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_5/RDF_Combination_SubClass_5-import001 . @prefix rdfs: . ex:C rdfs:subClassOf ex:D . ]]> RDF_Combination_SubClass_5-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_5/RDF_Combination_SubClass_5-premise.rif ) ) ]]> RDF_Combination_SubClass_5-nonconclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_5/RDF_Combination_SubClass_5-nonconclusion.rif Approved BLD http://www.w3.org/ns/entailment/Simple Test interaction between rdfs:subClassOf and ## statements in RIF In RIF-RDF combinations, we have that RIF ## statements imply rdfs:subClassOf statements. RDF_Combination_SubClass_6-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_6/RDF_Combination_SubClass_6-import001 RDF_Combination_SubClass_6-premise.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_6/RDF_Combination_SubClass_6-premise.rif ) Import( ) Group ( ex:C ## ex:D ) ) ]]> RDF_Combination_SubClass_6-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/RDF_Combination_SubClass_6/RDF_Combination_SubClass_6-conclusion.rif ex:D] ]]> Approved BLD http://www.w3.org/ns/entailment/RDF This test case illustrates the use of guard predicates with built-ins, as well as RDF+BLD combinations. The first rule says that a child is eligible for a "young-parents" discount if the difference between the child's age and one of the parent's age is less than 25 years. The second rule says that if a parent's age is not numeric, the parent will be marked as needing to be checked for eligibility. Note that external built-ins can be nested arbitrarily. Note also that built-ins in RIF are defined for arguments of specific datatypes. When an argument is not of the appropriate datatype, it is an error. Since the model-theoretic semantics for RIF does not include the notion of an error, the values of built-in predicates and functions are unspecified in such cases. In order to enable writing of rule sets with controlled behavior, RIF defines guard predicates for each datatype. YoungParentDiscount_1-import001.rdf http://www.w3.org/2005/rules/test/repository/tc/YoungParentDiscount_1/YoungParentDiscount_1-import001 . @prefix xs: . ex:littleJoeDoe ex:parent ex:JoanDoe, ex:JohnDoe . ex:littleJoeDoe ex:age 10 . ex:JohnDoe ex:age 34 . ex:JoanDoe ex:age "29"^^xs:string . ]]> YoungParentDiscount_1-premise.rif http://www.w3.org/2005/rules/test/repository/tc/YoungParentDiscount_1/YoungParentDiscount_1-premise.rif ) Prefix(func ) Prefix(pred ) Import( ) Group ( Forall ?c ?p ?ca ?pa( ?p # ex:YoungParent :- And( ?c[ ex:parent -> ?p ex:age -> ?ca ] ?p[ ex:age -> ?pa ] External( pred:is-literal-integer( ?pa ) ) External( pred:is-literal-integer( ?ca ) ) External( pred:numeric-less-than(External( func:numeric-subtract( ?pa ?ca ) ) 25 ) ) ) ) Forall ?c ?p ?ca ?pa( ?p # ex:ParentToBeChecked :- And( ?c[ ex:parent -> ?p ex:age -> ?ca ] ?p[ ex:age -> ?pa ] Or ( External( pred:is-literal-not-integer( ?pa ) ) External( pred:is-literal-not-integer( ?ca ) ) ) ) ) ) ) ]]> YoungParentDiscount_1-conclusion.rif http://www.w3.org/2005/rules/test/repository/tc/YoungParentDiscount_1/YoungParentDiscount_1-conclusion.rif