anchor.diff:  * The expression `$x` is a parameter.
   
   . `MATCH (a) RETURN a.x, 1 + count(a.x) ORDER BY a.x % 2`
  -* The sub-expression `a.x` is a grouping key.
  +* The sub-expression `a.x` is a recognized grouping key.
   * The sub-expression `2` is a constant.
   
   . `MATCH (a) WITH a.x AS ax RETURN ax, ax + count(ax) ORDER BY ax`
  -* The expression `ax` is a grouping key.
  +* The expression `ax` is a recognized grouping key.
   
   . `MATCH (a)-[]->(b) RETURN a, a.x + count(b.y) ORDER BY a.y`
  -* The sub-expression `a` is a grouping key.
  +* The sub-expression `a` is a recognized grouping key.
   
   . `MATCH (a)-[]->(b) RETURN a, count(b.y) ORDER BY size(keys(a))`
  -* The sub-expression `a` is a grouping key.
  +* The sub-expression `a` is a recognized grouping key.
   
   . `MATCH (x) RETURN x.a, x.b, x.c, x.a + x.b + count(x) + x.c ORDER BY x.a + x.c`
  -* The sub-expressions `x.a` and `x.c` are grouping keys.
  -
  -. `MATCH (a) RETURN a.x + 1, a.x + 1 + count(a.x) ORDER BY a.x + 1`
  -* The sub-expression `a.x + 1` is a grouping key.
  -
  -. `MATCH (a) WITH a.x + 1 as ax RETURN ax, ax - 1 + count(ax)`
  -* The sub-expression `ax` is a grouping key.
  +* The sub-expressions `x.a` and `x.c` are recognized grouping keys.
  +
  +. `MATCH (a) WITH a.x + 1 as ax RETURN ax, ax - 1 + count(ax) ORDER BY ax - 1`
  +* The sub-expression `ax` is a recognized grouping key.
   * The sub-expression `1` is a constant.
   
   . `MATCH (a) WITH a.x + 1 as ax RETURN ax, ax - 1 + count(ax) ORDER BY ax + 2`
  -* The sub-expression `ax` is a grouping key.
  +* The sub-expression `ax` is a recognized grouping key.
   * The sub-expression `2` is a constant.
   
   . `MATCH (a) WITH a.x + 1 as ax RETURN ax AS x, ax - 1 + count(ax) ORDER BY x + 2`
  -* The sub-expression `x` is an alias.
  +* The sub-expression `x` is an recognized alias.
   * The sub-expression `2` is a constant.
   
   . `MATCH (a) WITH a.x + 1 as ax RETURN ax AS x, ax - 1 + count(ax) AS y ORDER BY x + 2 - y`
  -* The sub-expressions `x` and `y` are aliases.
  +* The sub-expressions `x` and `y` are recognized aliases.
   * The sub-expression `2` is a constant.
   
   . `WITH {a:1, b:2} AS map RETURN map.a, map.a + count(map.b) ORDER BY map.a`
  -* The expression `map.a` is a grouping key.
  -
  -. `MATCH (x) RETURN x.a + x.b + x.c, x.a + x.b + x.c + count(x) ORDER BY x.a + x.b + x.c`
  -* The expression `x.a + x.b + x.c` is a grouping key.
  +* The expression `map.a` is a recognized grouping key.
   
   === Invalid orderings
   
  
positive.code: .[[Q6]]Q6
  [source, cypher]
  ----
  RETURN b-a AS x, c AS c, c + SUM(b) AS sumBC
  ----
  
  _GROUPING_KEYS_(_L_) is {`b-a`, `x`, `c`}.
  
  ====
  
  For an expression _ex_ and a projection list _L_, let _CONSTANT_(_ex_, _L_) hold
  
  * If _ex_ is either
  ** A aggregation function, i.e. of the form `_agg_(_subEx_)`,
  ** A grouping key, i.e. _ex_ ∈ _GROUPING_KEYS_(_L_),
  ** A constant, or
  ** A parameter,
  * or if _ex_ comprises of sub-expressions, it only comprises sub-expressions _subEx_ for which _CONSTANT_(_subEx_, _L_) holds.
  
  [IMPORTANT]
  .Syntax restriction
  
negative.code: Cypher's WITH and RETURN clause are syntactically more flexible than the two baseline semantics.
  In particular, they allow mixing aggregation and projection rather freely.
  
  Specifically, the WITH and the RETURN clause denote the parameters for projection (_P_) and aggregation (_K_ and _A_) with a single nonempty duplicate-free list _L_ of https://raw.githack.com/openCypher/openCypher/master/tools/grammar-production-links/grammarLink.html?p=ProjectionItem[<ProjectionItem>]s `_ex_ AS _al_` where
  
  * _ex_ is an expression that is allowed to contain aggregation functions and
  * _al_ is an alias.
  