<csma> item+ Admin

<csma> item+ Liaison

<csma> item+ Public comments

<csma> item+ Action review

<csma> item+ Safeness

<csma> item+ issue 80 (meta-builtins)

<csma> item+ issue 81 (OWL-RL datatypes)

<csma> item+ issue 90 (rif:iri and rdf:text in RDF graphs)

<csma> item+ test cases

<csma> item+ AOB

<csma> Adrian, will you scribe?

yes

<csma> scribe: Adrian Paschke

Zakim seems to have a problem

<csma> Scribenick: AdrianP

<ChrisW> kick zakim #rif

<AxelPolleres> trying to dial in

<StellaMitchell> stella

<ChrisW> Attendence: Christian, ChrisW, Changhai, Jos, Leora, Harold, Adrian, Gary, DaveR, Stella

<ChrisW> Attendees: Christian, ChrisW, Changhai, Jos, Leora, Harold, Adrian, Gary, DaveR, Stella

<ChrisW> Attendees: Christian, ChrisW, Changhai, Jos, Leora, Harold, Adrian, Gary, DaveR, Stella, Sandro

<csma> next item

<AxelPolleres> I am here as well

<ChrisW> Attendees: Christian, ChrisW, Changhai, Jos, Leora, Harold, Adrian, Gary, DaveR, Stella, Sandro, Axel

<csma> item agenda

Admin

<scribe> scribe: Adrian Paschke

<scribe> scribe: AdrianP

<csma> PROPOSED:* accept minutes of F2F12

csma: accept minutes of F2F12

<csma> http://www.w3.org/2005/rules/wg/meeting/2009-01-14

<csma> http://www.w3.org/2005/rules/wg/meeting/2009-01-15

csma: no objection - resolved

<csma> RESOLVED: accept minutes of F2F12

csma: accept minutes Jan. 20

<csma> PROPOSED: to accept the minutes of Jan 20

<csma> http://lists.w3.org/Archives/Public/public-rif-wg/2009Jan/att-0091/20-January-09-rif-minutes.htm

<csma> RESOLVED: to accept the minutes of Jan 20

<csma> PROPOSED: to accept the minutes of Jan 27

<csma> http://lists.w3.org/Archives/Public/public-rif-wg/2009Jan/att-0092/2009-01-27-rif-minutes.html

<csma> RESOLVED: to accept the minutes of Jan 27

Liason

ChrisW: share common semantics for datatypes between OWL WG and RIF WG
... discuss if there can be one common set of datatypes

Axel: SPARQL working group just reopened
... I'm chairing it
... will forward the link to the new charter
... liaison makes sense - first phase: SPARQL updates
... valuable work done in RIF SWC
... time schedules for SPARQL WG will be discussed next week

csma: Axel liaison for SPARQL

<AxelPolleres> Let me know if someone else is joining (will see that anyways)

Adrian: HCLS currently looks into federated SPARQL queries

<AxelPolleres> SPARQL charter: http://www.w3.org/2009/01/sparql-charter.html

Adrian: and linked open data

F2F13

Axel: F2F13 at WWW09
... would be in Europe
... talked to my former affiliation
... reachable by Metro (but outside of Madrid)
... problem might be speaker phone

<DaveReynolds> I would almost certainly need to phone in.

Axel: we rely on what the university can offer

Can we use Voice over IP?

csma: will discuss it further with Sandro and Chris

Axel: might be possible to attend Boston
... Have it collocated with the W3C AC meeting in Boston

csma: many other constraints AAAI meeting, OMG meeting

<sandro> According to http://www.w3.org/2002/09/wbs/38457/f2f13_dates/results, everyone said they could attend in Boston April 15-17

csma: action review

Action review

csma: 700 closed
... 697 closed

csma 695 closed

csma 695 continued

csma 954 (not 695) continued

csma 693 closed

<sandro> action-693 closed

<trackbot> ACTION-693 Push back on OWL-WG about disjoint value spaces closed

action-690 closed

<trackbot> ACTION-690 Specify core as a specialisation of PRD closed

action-688 closed

<trackbot> ACTION-688 Write some safeness test cases closed

<ChrisW> ooh

action-687 closed

<trackbot> ACTION-687 Write a proposed new definition of the safeness restriction closed

action-685 closed

<trackbot> ACTION-685 Write a test case or two to illiustrate how ## and rdfs:subClassOf relate closed

<csma> to add a version of http://www.w3.org/2005/rules/wiki/RDF_Combination_Constant_Equivalence_2 with the import having a ^^xs:string

<josb> http://www.w3.org/2005/rules/wiki/RDF_Combination_Constant_Equivalence_4

action-684 closed

<trackbot> ACTION-684 to add a version of http://www.w3.org/2005/rules/wiki/RDF_Combination_Constant_Equivalence_2 with the import having a ^^xs:string closed

action-683 closed

<trackbot> ACTION-683 Ask Dave to have a look at ISSUE-81 before F2F12 closed

action-682 closed

<trackbot> ACTION-682 Edit ISSUE-81 to explain the technical reason that make owl:real, xsd:hexBinary, xsd:base64Binary incompatible with RIF current data types closed

action-681 closed

<trackbot> ACTION-681 Update DTB to reflect resolution on guards closed

<ChrisW> action-681 pending review

action-588 continued

Sandro: did action-579

<csma> http://www.w3.org/2005/rules/wg/track/actions/pendingreview

csma: pending review actions

<sandro> action-579 closed

<trackbot> ACTION-579 Implement RIF-XML to PS translator closed

<ChrisW> action-631 closed

<trackbot> ACTION-631 Make a positive syntax test version of Argument names not Const closed

<ChrisW> action-664 closed

<trackbot> ACTION-664 Figure process for RDF errata (re: fixing rdf:xmlliteral) closed

<ChrisW> what a productive week!

<sandro> yeah!

Safeness

<josb> http://www.w3.org/2005/rules/wiki/Core#Safeness

<csma> http://www.w3.org/2005/rules/wiki/Core#Safeness

Jos: error with equality in the body - was to liberal - fixed it
... hard to read - tried to make it more readable

<josb> x=z

Jos: context is condition formula
... safeness is defined relativ to a context
... you need to consider context to decide if a variable is safe

cmsa: isn't it too general for Core?

<josb> x=x

Jos: necessary because of = in the body

<josb> x=z and p(z)

you want z to be safe

harold: if you have x=z it is not recursively safe

<AxelPolleres> x=y y=z z=x works with your def, jos?

Harold: x=x?

Axel: cyclic equality adressed?

Jos: right that is the idea

csma: leave defintion as is?

ChrisW: wondering if context should be on the quantification formula not on implication formulas?

Jos: in the quantifier you might have variables which are not used in the rule
... you have to distinguish two cases "used in rule" and "not"
... universial rule - if variable is never used it does not make the rule unsafe

<josb> p(?x)

<AxelPolleres> for the records, the definition allows infinite extensions of predicates, but we had discussed that on the mailinglist.

<josb> p(f(?x))

<josb> f(?x)

<josb> ?x

<AxelPolleres> http://lists.w3.org/Archives/Public/public-rif-wg/2009Jan/0090.html

<josb> x+y = y

<josb> x+y = z

<csma> P(?x) :- pred:greater-than(func:numeric-add(?x 1) 0)

<josb> p(x) q(y)

Jos: first 6 bullets ignore built-ins

Axel: we discussed termination vs. non-termination in forward reasoning

<AxelPolleres> a(1).

<AxelPolleres> a(Y) :- a(X), func:numeric-add(X,1) = Y.

Jos: need to revise it again to cover this

Sandro: try a pseudo code version of this

Jos: will first revise it and make it easier to understand

<cke> The old definition looks to be more understandable. Can we adapt it?

csma: isn't there an accepted definition of safeness

Axel: yes, but only for Datalog
... not for built-ins

<ChrisW> ACTION: jos to correct safeness definition (wrt mapping for variables) [recorded in http://www.w3.org/2009/02/03-rif-minutes.html#action01]

<trackbot> Sorry, amibiguous username (more than one match) - jos

<trackbot> Try using a different identifier, such as family name or username (eg. jdebruij2, jderoo)

<sandro> it's josb

<ChrisW> ACTION: josb to correct safeness definition (wrt mapping for variables) [recorded in http://www.w3.org/2009/02/03-rif-minutes.html#action02]

<trackbot> Created ACTION-702 - Correct safeness definition (wrt mapping for variables) [on Jos de Bruijn - due 2009-02-10].

cmsa: you wanted termination if forward chaining

<josb> only for a very naive implementation

Axel: yes, otherwise it will not terminate

csma: check termination outside of the rule system

<Harold> We are taking about 'pure' production rules -- otherwise the 'halt' statement could be used.

<sandro> I think we're talking about static analysis of rulesets to see if they are guaranteed to terminate.

Axel: know a Datalog system which has forward chaining
... and would not terminate

csma: general problem of "forward Datalog"
... ?

Dave: too me it is a problem with a rule set

<AxelPolleres> If it is a problem with the ruleset, then it shouldn't be core.

<sandro> DaveReynolds: The question is whether you ALLOW people to write non-terminating rulesets.

Dave: issue of the conformance clause

<sandro> axel: the whole idea of safeness was to guarantee termination

Axel: idea of safeness condition was to guarantee that calculation terminates and produces results

csma: if rule set implies infite model I don't see a problem from the conformance point of view

Axel: these systems are very simple - do naive grounding and forward reasoning

<josb> should we really care about such naive implementations?

<sandro> no, that's not it.

<sandro> ?

cmsa: your concern is that Core rule sets in these engines will lead to non termination

Axel: yes

csma: do we have a test case?

<Zakim> sandro, you wanted to ask if there are systems which will reject rulesets which terminate, but don't pass the syntax tests which guarantee termination

<DaveReynolds> http://www.w3.org/2005/rules/wiki/Chaining_strategy_numeric-add_1 is that an example?

Sandro: the Axel's system will reject the rule set by a syntactic test?

<sandro> axel: the checking could be turned off.

<AxelPolleres> a(Y) :- a(X), func:numeric-add(X,1) = Y.

<AxelPolleres> a(Y) :- a(X), func:numeric-add(X,1) = Y.a(Y) :- a(X), func:numeric-add(X,1) = Y.

Axel: yes

<AxelPolleres> b(Y) :- a(X), func:numeric-add(X,1) = Y.

Axel: this rule would be fine - without recursion

<AxelPolleres> http://www.w3.org/2005/rules/wiki/Chaining_strategy_numeric-add_1

csma: issue of finiteness is that there are some rule engine which will reject unfinite Core rule sets

<sandro> it's about what to do with "Potentially Non-Terminating Rulesets"

<josb> Sandro, it's the program that does not terminate, not the ruleset

Axel: even if a syntactic check will be switched of the rule engine will simply not terminate

<cke> The rule is not safe because variable X is not bound. right?

<sandro> sure, Jos, I'm simplifying a little.

Axel: all ASP engine would not accept this kind of rule set

<sandro> (Answer Set Programming)

<Harold> Dave mentioned a recursion test earlier. Here we could have (except we would need to choose a MAXINT): a(Y) :- a(X), pred:numeric-less-or-eq(X,MAXINT), func:numeric-add(X,1) = Y

Axel: they do some forward chaining checks

<DaveReynolds> Can we require conformance only over rulesets with finite models?

<sandro> I don't think that helps, Dave.

csma: could be handeled by conformance clause
... as Dave suggested

sandro: problem is that the systems can only do syntactic check

<AxelPolleres> The system which excepts non-recursive use of fuilt-in predicates is already an advanced one.

Dave: not sure if we can have a definition for all the different systems

<AxelPolleres> examples for important rulesets?

csma: we are back to discussion of conformance clauses of Core

Sandro: we need more data

<josb> I think I managed to technically fix the definition: http://www.w3.org/2005/rules/wiki/Core#Safeness

<sandro> Sandro: How important are little-core (finite core) and big-core (infinite core) in the world, and can we drop one of them.... Need more data.

<josb> I still have to improve the presentation, though

<ChrisW> ACTION: axel to investigate implementations that will reject infinite rulesets [recorded in http://www.w3.org/2009/02/03-rif-minutes.html#action03]

<trackbot> Created ACTION-703 - Investigate implementations that will reject infinite rulesets [on Axel Polleres - due 2009-02-10].

<Harold> Can we have MAXINT, MAXDOUBLE, MAXFLOAT, and the other few ones that can prevent that we run into infinite models in the absence of function symbols?

<AxelPolleres> I would really like to see the important examples, indeed.

<LeoraMorgenstern> I will try to think of some, but I don't want to take an action to do this.

Garry; business rules typically use rule fire limit (meta data)

<AxelPolleres> A *practical* ruleset that isn't guaranteed to terminate, please.

<sandro> ie one that falls back on the halting problem, instead of the easier syntactic checks.

Jos: Axel needs to specify the restrictions when a rule set does not terminate

<sandro> axel: "strong safeness" based on the dependency graph of the ruleset

<LeoraMorgenstern> Sandro, are you thinking of some complicated double recursion, that would not be obvious syntactically?

<Harold> Of course we are fine that things like p(1) :- p(2), p(2) :- p(1) won't terminate.

DTB

<sandro> well, that will terminate, Harold, with anything but a completely-naive forward chainer.

Issue-80

<sandro> issue-80?

<trackbot> ISSUE-80 -- Shoudl we extend DTB to include more general builtins -- OPEN

<trackbot> http://www.w3.org/2005/rules/wg/track/issues/80

Axel: removed all type specific guards
... they are redundant due to new predicates

<Harold> No, Sandro, "things like this" are not decidable in the general case.

Axel: equality issue: equal and non equal datatype for all numeric datatypes

<AxelPolleres> with the following semantics:

<AxelPolleres> literal-equal is true if and only if arguments equal and in the

<AxelPolleres> valuespace of any of the supported datatypes, false otherwise.

<AxelPolleres> literal-not-equal is true if and only if arguments are in the

Axel: replace equal with non-equal predicates

<AxelPolleres> valuespace of any of the supported datatypes and unequal, false otherwise?

csma: equal / not-equal should also work with datatype with disjoint value spaces?

Axel: covered by this definition

<sandro> Harold, one of the control strategies I'm used to is that you stop firing rules when no new facts are inferred. That'll handle your case, right?

Axel: no casting in this definition

csma: but for numeric datatype?

ChrisW: replacing type specific equality predicates with one that takes it as an argument?

Axel: not aware of this
... we still would need to take care that the variables are bound

<AxelPolleres> # 3.3.2.1 pred:numeric-equal (adapted from op:numeric-equal)

<AxelPolleres> # 3.3.2.4 pred:numeric-not-equal

<AxelPolleres> * xs:double

<AxelPolleres> * xs:integer

<AxelPolleres> * xs:decimal

<AxelPolleres> # 3.4.2.5 pred:string-equal

<AxelPolleres> # 3.4.2.8 pred:string-not-equal

<AxelPolleres> * xs:string

<AxelPolleres> # 3.5.2.1 pred:dateTime-equal (adapted from op:dateTime-equal)

<AxelPolleres> # 3.5.2.15 pred:dateTime-not-equal

<AxelPolleres> * xs:dateTime

<AxelPolleres> # 3.5.2.4 pred:date-equal (adapted from op:date-equal)

<AxelPolleres> # 3.5.2.18 pred:date-not-equal

<AxelPolleres> * xs:date

<AxelPolleres> # 3.5.2.7 pred:time-equal (adapted from op:time-equal)

<AxelPolleres> # 3.5.2.21 pred:time-not-equal

<AxelPolleres> * xs:time

<AxelPolleres> # 3.5.2.10 pred:duration-equal (adapted from op:duration-equal)

<AxelPolleres> # 3.5.2.24 pred:duration-not-equal

<AxelPolleres> * xs:dayTimeDuration

<AxelPolleres> * xs:yearMonthDuration

<AxelPolleres> * 3.6.1 pred:XMLLiteral-equal

<AxelPolleres> * 3.6.2 pred:XMLLiteral-not-equal

<AxelPolleres> * rdf:XMLLiteral

<AxelPolleres> # 3.7.2.2 pred:text-equalD

<AxelPolleres> # 3.7.2.5 pred:text-not-equal

csma: difference between string and text

Axel: rdf:text and string

csma: 10 as integer and 10 as decimal - do they refer to numeric-equal

Jos: on F2F in Paris we had a decision to have this predicates?

<AxelPolleres> http://www.w3.org/TR/xpath-functions/#func-numeric-equal

csma: generic equality / unequality would automatically support the RIF datatypes

<Harold> Sandro, for Core we should have termination both under forward and backward reasoning.

<AxelPolleres> guess we can't close that now

continue next time

<sandro> Harold, practical termination yes, but guaranteed termination for all rulesets that can be written? That might be too restrictive.

<cke> I agree with "for Core we should have termination both under forward and backward reasoning", if we ever have termination concept

<ChrisW> ACTION: axel to add the generic equality predicates to DTB for discussion (editors note this is still under discussion) [recorded in http://www.w3.org/2009/02/03-rif-minutes.html#action04]

<trackbot> Created ACTION-704 - Add the generic equality predicates to DTB for discussion (editors note this is still under discussion) [on Axel Polleres - due 2009-02-10].

bye

<AxelPolleres> jos, rationale is: to make things simpler, I know that this would contradict the paris decision.

<AxelPolleres> anyways, I am not religious about dropping the type specific eaualities.

<AxelPolleres> ... just fulfilled the action to look into that. ;-)

<ChrisW> Michael_Kifer, were you on the call?

<ChrisW> As of this point the attendees have been Attendees: Christian, ChrisW, Changhai, Jos, Leora, Harold, Adrian, Gary, DaveR, Stella, Sandro, Axel

This is scribe.perl Revision: 1.133  of Date: 2008/01/18 18:48:51  
Check for newer version at http://dev.w3.org/cvsweb/~checkout~/2002/scribe/

Guessing input format: RRSAgent_Text_Format (score 1.00)

Succeeded: s/rules/rulesets/
Succeeded: s/that can lead /that can prevent that we run in/
Found Scribe: Adrian Paschke
Found ScribeNick: AdrianP
Found Scribe: Adrian Paschke
Found Scribe: AdrianP
Inferring ScribeNick: AdrianP
Scribes: Adrian Paschke, AdrianP
Default Present: (none)
Present: Christian ChrisW Changhai Jos Leora Harold Adrian Gary DaveR Stella Sandro Axel
Regrets: PaulVincent HassanAit-Kaci
Agenda: http://lists.w3.org/Archives/Public/public-rif-wg/2009Feb/0009.html
Got date from IRC log name: 03 Feb 2009
Guessing minutes URL: http://www.w3.org/2009/02/03-rif-minutes.html
People with action items: axel jos josb

WARNING: Input appears to use implicit continuation lines.
You may need the "-implicitContinuations" option.