Translation of property path patterns incomplete

[hartig]

Section 18.2.2.4 Translate Property Path Patterns contains a table that defines the translation of property path patterns into the algebraic syntax. I assume that the translation rules in this table are meant to be applied recursively, but the section doesn't say anything about that. In this sense, the definition of this translation step is incomplete.

To describe the issue in more detail, consider the following row of the table.

+----------------+-----------------+
| Algebra (path) | Translation     |
+----------------+-----------------+
...
| X seq(P, Q) Y  | X P ?V . ?V Q Y |
...

The P and the Q in this case may be arbitrary property path expressions. Therefore, the translation needs to be applied again to each of the two resulting property path patterns in the "Translation" column of this table (i.e., to X P ?V and to ?V Q Y).

[afs]

(I hope I'm wrong on this!)

I assume that the translation rules in this table are meant to be applied recursively

They can be applied recursively - that's top-down, and doesn't means they will replace all occurrences. They don't go through ZeroOrMorePath, for example, to touch it's argument. The argument is a ppe; the translation does not produce property path expressions. The translation does open up the simple property paths to be triple matching to semantic extensions that extend basic graph pattern matching.

The text
"These are only applied to property path patterns, not within property path expressions."
capture this (it should say it's repeat application until no change - top-down recursion).

In a property path ?X (:p/:q)* ?Y the * becomes ZeroOrMorePath of an algebraic property path expression.

:p/:q remains a seq. It can't be a triple translation at this stage. ?A :p ?B . ?B :q ?C is not a ppe.

That has a consequence that in 18.5 Property Path Patterns"

"This leaves algebraic property path expressions is ..."

still includes inv, seq and linkas well as alt being added by #306.

[hartig]

(I hope I'm wrong on this!)

I think you are.

I assume that the translation rules in this table are meant to be applied recursively

They can be applied recursively - that's top-down, and doesn't means they will replace all occurrences.

IMO, they should replace all occurrences, and the issue is that the current definition does not explicitly require that.

I am aware that the translation rules do not go through all PPEs. For every PPE through which they don't go, the property path pattern with that PPE still needs to be translated, from x ppe y to Path(x, ppe, y), and that's exactly what the last row of the table in Section 18.2.2.4 Translate Property Path Patterns does. So, all is good in that respect.

My issue is related to the third rule in the table (the one for seq). This rule produces two new property path patterns, namely "x ppe1 var" and "var ppe2 y", and the section does not say that the rules should be applied again to these two property path patterns.

[afs]

(I hope I'm wrong on this!)

I think you are.

You have a different reading of the text. This shows a weakness of the text.

I read a "translation" as meaning "applying everywhere".
And that would include inside ZeroOrMorePath.

I think we are agreed as to the fix for this.

View it as functional and write:

+----------------+---------------------------------------+
| Algebra (path) | Transformation                        |
+----------------+---------------------------------------+
...
| X seq(P, Q) Y  | X transform(P) ?V . ?V transform(Q) Y |

[hartig]

I read a "translation" as meaning "applying everywhere". And that would include inside ZeroOrMorePath.

No, it cannot go inside ZeroOrMorePath. Consider a property path pattern PP that is of the form

x ZeroOrMorePath(ppe') y

where ppe' is some algebraic property path expression. The only rule of the table in Section 18.3.2.4 Translate Property Path Patterns that PP matches is the last (fourth) one. Consequently, the result of translating PP (by applying the last/fourth rule) is the algebraic query expression:

Path(x, ZeroOrMorePath(ppe'), y)

... and this one is not a property path pattern anymore and, thus, not considered any further for the translations in Section 18.3.2.4 Translate Property Path Patterns.

I think we are agreed as to the fix for this.

View it as functional and write:

+----------------+---------------------------------------+
| Algebra (path) | Transformation                        |
+----------------+---------------------------------------+
...
| X seq(P, Q) Y  | X transform(P) ?V . ?V transform(Q) Y |

No. The translation in this section is not anymore about translating the property path expressions that are inside the property path patterns. Instead, it is about translating the whole property path patterns. The translation of property path expressions happened before, and is covered by the definitions in Section 18.3.2.3 Translate Property Path Expressions.

The fix is to add another bullet point to the list of bullet points before the table in Section 18.3.2.4 Translate Property Path Patterns, saying something like:

• Whenever the third translation rule is used, then each of the resulting two property path patterns needs to be translated as well.

I would add this new bullet point in between the fourth and fifth of the current bullet points.

[afs]

I read a "translation" as meaning "applying everywhere". And that would include inside ZeroOrMorePath.

No, it cannot go inside ZeroOrMorePath.

I am agreeing with you.

[afs]

• Whenever the third translation rule is used, then each of the resulting two property path patterns needs to be translated as well.

I would add this new bullet point in between the fourth and fifth of the current bullet points.

I think we need an operational description, not text.

[hartig]

How's about the following?

Let PP be a property path pattern x ppe y. The translation of PP into an algebraic query expression, denoted by ppTranslate(PP), is defined recursively as follows.

If PP is of the form	then ppTranslate(PP) is
x link(iri) y	x iri y
x inv(iri) y	y iri x
x seq(ppe1, _ppe2) y	ppTranslate(x ppe1 var) ppTranslate(var ppe2 x)
any other	Path(x, ppe, y)