Re: Fwd: Re: Comments about the semantics of property paths

I think this should work for the sum age query.

{ ?F :age ?A
     { :me (:friend)+ ?F } }}

It seems that, in general, DISTINCT will work as a there exists query when URIs and blank nodes are the endpoint of a path because we have a one-to-one mapping between URI/BN values and graph vertices, but we get a one-to-many mapping from literal values to vertices.

- Matt

On 1/26/2011 8:24 AM, Andy Seaborne wrote:
> Here's an example. based on items in a (simple) shopping basket. There are two things that are :item1 in the order (via compound and directly - think "buying a spare part").
> The order cost is 6, uniqueness would make it 2.
> (I've sent a version of this to Jorge offlist as discussions aren't possible on the comments list).
>     Andy
> ==== D1.ttl
> @prefix : <http://example/> .
> :order :contains :thing1 .
> :order :contains :compound1 .
> :thing1 :unitOf :item1 .
> :thing2 :unitOf :item2 .
> :thing3 :unitOf :item1 .
> :item2 :price 2 .
> :item1 :price 2 .
> :compound1 :contains :thing2 .
> :compound1 :contains :thing3 .
> ==== Q1.rq
> PREFIX : <http://example/>
> SELECT (SUM(?itemPrice) AS ?price)
> {
>   :order :contains+/:unitOf/:price ?itemPrice .
> }
> -------- Original Message --------
> Subject: Re: Comments about the semantics of property paths
> Date: Tue, 25 Jan 2011 15:55:08 -0300
> From: jorge perez <>
> To: Andy Seaborne <>
> CC:
> Hello Andy,
> Thanks for your email. Yes, my comments have been answered. An
> additional comment is below.
> On Tue, Jan 25, 2011 at 1:08 PM, Andy Seaborne
> <> wrote:
>> Hi Jorge,
>> XPath is designed for XML processing where XML nodes and values are treated
>> in different ways. XPath evaluation returns distinct XML nodes, but
>> duplicate values. One evaluation of an XPath expression can't mix XML nodes
>> and values - see the numbered list in [1]. "XQuery 1.0 and XPath 2.0
>> Functions and Operators" has an operation fn:distinct-values to make values
>> unique in a sequence [2].
>> An RDF graph does not have this distinction of nodes and values. Graph nodes
>> (vertexes) are IRIs, blank nodes or literals with no separation. Repetition
>> of literals is significant, consider SUM applied to a purchase order where
>> two items have the same price, so multiple paths to the same endpoint do
>> matter.
> Aggregation is actually another reason of why multiple paths to the
> same endpoint *do not* have to be considered.
> Consider a network of friends, and assume that you want to obtain the
> SUM of the age of all your network (friends of your friends). Then a
> very natural way to do this is with the query (simplified syntax)
> SUM (?A)
> :me (:friend)+/:age ?A
> The query is navigating to all the friends of my friends, then to the
> age value of every one, and then taking the SUM. Isn't this natural?
> But, consider the following data
> :me :friend :f1
> :me :friend :f2
> :f1 :friend :f2
> :f1 :age 20
> :f2 :age 20
> I would expect 40 as the result of the above query, but the expression
> :me (:fiend)+/:age ?A
> returns
> ?A
> 20 (for the path :me->:f1)
> 20 (for the path :me->:f2)
> 20 (for the path :me->:f1->:f2)
> and thus, the answer of the SUM would be 60. How do you explain the
> result of this query to a user? Notice that using DISTINCT does not
> solve the problem, since with DISTINCT you would obtain 20 as the SUM
> which is also wrong.
> Is there a way to correctly answer the above query with the current
> design of property paths?
> Thanks,
> - jorge
>> SPARQL property paths do not apply uniqueness to property paths and the
>> property path expression is, where appropriate, the same the expansion in
>> terms of triple patterns. It is not a matter of efficiency because the
>> answers concerning duplicate literal values would be rather unexpected if
>> only distinct values were returned.
>> This leaves the ArbitraryLengthPath operation for the use of "+" in paths.
>> This traverses cycles once by terminating the search on encountering an edge
>> already traversed for that evaluation of ArbitraryLengthPath. In an earlier
>> design, cycle termination was by detecting visiting nodes but the WG
>> considers the edge traversal a better choice. The new design is one more
>> step of evaluation on a cycle than the first design and leaves better
>> prospects for future standardization.
>> SPARQL has the keyword DISTINCT so an application can choose between
>> duplicates and no duplicates. A query engine can exploit this if it chooses
>> to; use with sub-queries mean that solution modifiers can be applied to
>> specific parts of the query such as a path.
>> An implementation is free to implement evaluation in anyway it chooses
>> proved it results in the same answers. The WG felt that using an algorithm
>> was the most helpful way to specify the feature, especially to implementers.
>> Property paths have been implemented in a number of systems (see [3] for a
>> partial list) and found to be useful.
>> We would be grateful if you would acknowledge that your comment has been
>> answered by sending a reply to this mailing list.
>> Andy
>> On behalf of the SPARQL working group.
>> [1]
>> [2]
>> [3]
>> On 15/12/10 18:34, jorge perez wrote:
>>> Hello Andy,
>>> Thank you very much for your response and for considering my comments,
>>> and sorry for the late reply.
>>> There is a couple of comments that you have not answered.
>>> ""
>>> As a separate but very important issue, notice that the XPath language
>>> does not consider duplicate paths when evaluating expressions (XPath
>>> is evaluated in the "there exists" way that I mentioned before). Thus,
>>> counting paths in SPARQL would be somewhat in contradiction with
>>> previously proposed path languages considered by the W3C.
>>> ""
>>> I think that if this W3C Recommendation is in discordance with a
>>> previous Recommendation about a similar topic, then DAWG should have
>>> strong reasons for that, and make them clear in the specification. The
>>> specification should also advice the reader about this issue.
>>> Besides that comment, you have said nothing about efficiency of
>>> evaluation. Notice that this not related to a particular way of
>>> implementing the language. It is about the huge efficiency impact that
>>> any implementation will suffer in practice. You have not acknowledge
>>> that in your response. Have you consider this as an issue?
>>> Another comment that is not covered by your response is whether there
>>> exists a use case that demand counting different paths. In your
>>> response, it seems that the reason for counting paths is to make
>>> easier the job of the implementors (by reusing algebra operators).
>>> Opposite to what the group think, I think that not counting paths
>>> gives the implementor more freedom since paths could be implemented in
>>> several different ways, being just one of them by reusing algebra
>>> operators. Can you please clarify whether there are use cases about
>>> this? This would help a lot.
>>> If you respond to the comments above I can consider my comments answered.
>>> I have a couple of additional words. Please do not consider them as a
>>> formal objection to the process, but just as my opinion.
>>> I still strongly disagree with your design decisions about property
>>> paths. In particular, I insist that it is a mistake to define the
>>> semantics in the presence of cycles in a non-standard way and by
>>> forcing a particular algorithm to evaluate them. In your response you
>>> say that there can be corner cases, but it is not only a problem of
>>> corner cases. From my point of view it will become a problem of
>>> adoption of the standard. In this point I think that the group should
>>> not neglect that there is a lot of related (theoretical and practical)
>>> work in this area that have handled cycles in a completely different
>>> way.
>>> To conclude, I do think that the property-paths material in the
>>> current specification is far from being mature. Considering that the
>>> group is in a tight schedule, I think that it would be better to not
>>> include property paths in this round of standardization, than
>>> including them in their current form.
>>> Thank you very much for considering my comments.
>>> - jorge
>>> On Thu, Dec 2, 2010 at 8:20 AM, Andy Seaborne
>>> <>  wrote:
>>>> Jorge,
>>>> Thank very much for your comments.
>>>> The working group considered a number of factors in designing the
>>>> property
>>>> path features. In addition to the points you raise, the WG also included
>>>> consideration that, while this working group is not adding a path
>>>> datatype
>>>> (needed to inquire about any path matched later in the query), nor the
>>>> specific case of access to path length, the WG should leave open as many
>>>> possibilities here for future work. Another factor in the design is the
>>>> relationship of some property path expressions to triple pattern forms.
>>>> Although not specifying returning the path length of a match, nor
>>>> specifying
>>>> returning the matched path itself, the WG felt that, on balance, the
>>>> design
>>>> in the working draft gave maximum scope for any later standardization
>>>> work.
>>>> The issue of path length particularly was considered as a feature for
>>>> this
>>>> round of work but, when considered against all the other work items the
>>>> WG
>>>> has taken on, it didn't make the final list of work items. This lead to
>>>> the
>>>> conclusion that counting path possibilities, not a "there exists"
>>>> condition,
>>>> was the better choice for this round of standardization. Adding access
>>>> the
>>>> the path matched is better served if all paths are considered.
>>>> Another consideration was the relationship of property paths and existing
>>>> queries using triple patterns.
>>>> { ?x :p{2} ?y }
>>>> and
>>>> { ?x :p ?Z . ?Z :p ?y }, with ?Z projected away.
>>>> The WG decided to make these equivalent, including in terms of numbers of
>>>> solutions. This gives the semantics of many path forms in terms of SPARQL
>>>> graph pattern operators. This was felt to be intuitive and to utilize the
>>>> capabilities of query engines: rather that requiring yet another
>>>> mechanism,
>>>> the equivalence means that join-technology (for example) can be used to
>>>> solve the pattern.
>>>> This then leaves the issue of cycles in the "+" operator. The design is
>>>> one
>>>> in which the cycles in "+" operator are handled by traversing a directed
>>>> edge (triple in the data) once. This will be explained in the final
>>>> version
>>>> of the query specification - there is a placeholder for it in the current
>>>> editors working draft. The current working draft has been clarified to
>>>> use
>>>> "multiset-union" for the union in the ArbitraryLengthPath definition.
>>>> This overall design is a tradeoff of implementation, future
>>>> possibilities,
>>>> and equivalence of patterns on graphs. The WG is aware that there can be
>>>> corner cases can arise where different intuitions are not compatible. On
>>>> balance, the WG feels that the current design is most suitable for this
>>>> round of standardization.
>>>> Again, that you for your helpful comments.
>>>> We would be grateful if you would acknowledge that your comment has been
>>>> answered by sending a reply to this mailing list.
>>>> Andy
>>>> on behalf of the SPARQL Working Group.

Received on Wednesday, 26 January 2011 13:54:47 UTC