anchor.diff:  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 denoted the parameters for projection (_P_) and aggregation (_K_ and _A_) with a single nonempty set _L_ of https://raw.githack.com/openCypher/openCypher/master/tools/grammar-production-links/grammarLink.html?p=ProjectionItem[<ProjectionItem>]s `_ex_ AS _al_` where
  +Specifically, the WITH and the RETURN clause denoted 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.
  
positive.code: 
  To prevent such invalid rewrites, this CIP imposes a syntax restriction on RETURN and WITH clauses.
  
  Given a set of <ProjectionItem>s _L_ = {_p_~1~, _p_~2~, ... _p~N~_}, let GROUPING_KEYS(_L_) be the set of all expressions and _ex_ and aliases _a_ in <ProjectionItem>s _p_ = `_ex_ AS _a_` in _L_ where _AGG_(_p_) is empty.
  
  For an expression _ex_ and projection list _L_, let CONSTANT(_ex_) hold
  
  * If _ex_ is either
  ** A aggregation function, i.e. of the form `_agg_(_subEx_)`,
  ** A grouping key (either expression or alias), i.e. _o_ ∈ GROUPING_KEYS(_L_),
  ** A constant,
  ** A parameter
  * or if _ex_ comprises of sub-expression, it only comprises sub-expression _subEx_ for which CONSTANT(_subEx_) holds.
  
  [IMPORTANT]
  .Syntax restriction
  ====
  For clauses `WITH _L_` and `RETURN _L_` and every _p_ = `_ex_ AS _a_` in _L_ where _AGG_(_p_) is not empty, CONSTANT(_ex_) shall hold.
  ====
  
  .Effect of the restriction
  
negative.code: 
  For a <ProjectionItem> _p_ = `_postEx_ AS _al_`, let _AGG_(_p_) be the set of (sub-)expressions _aggex_ of the form _agg_(_preEx_), i.e. _AGG_(_p_) = _AGG_(_postEx_).
  
  The <ProjectionItem>s in _L_ is split according to _AGG_(_p_) in two cases
  
  * <ProjectionItem>s _p_ in _L_ is an aggregate if _AGG_(_p_) is non-empty
  * <ProjectionItem>s _p_ in _L_ is a grouping key if _AGG_(_p_) is empty
  
  For a <ProjectionItem> _p_ = `_ex_ AS _al_`,
  
  * If _AGG_(_p_) = ∅
  ** Let `_PRE_PROJ_(_p_)` be `_ex_ AS _al_`,
  ** Let `_AGGR_(_p_)` be `_al_ AS _al_`, and
  ** Let `_POST_PROJ_(_p_)` be `_al_ AS _al_`
  * If _AGG_(_p_) = {`_agg_~1~(_preEx_~1~)`, `_agg_~2~(_preEx_~2~)`, ..., `_agg~N~_(_preEx~N~_)`} with _N_ > 0
  ** Let `_PRE_PROJ_(_p_)` be `_preEx_~1~ AS _al_+++_+++1, _preEx_~2~ AS _al_+++_+++2, ..., _preEx~N~_ AS _al_+++_+++_N_`,
  ** Let `_AGGR_(_p_)` be `_agg_~1~(_al_+++_+++1) AS _al_+++_+++1, _agg_~2~(_al_+++_+++2) AS _al_+++_+++2, ..., _agg~N~_(_al_+++_+++_N_) AS _al_+++_+++_N_`, and
  ** Let `_POST_PROJ_(_p_)` be `_postEx_ AS _al_` where _postEx_ is _ex_ with each `_agg~i~_(_preEx~i~_)` in _AGG_(_p_) being replaced by `_al_+++_+++_i_` for 1 ≤ _i_ ≤ _N_.
  
  [IMPORTANT]
  .Rewrite semantics
  ====
  `RETURN _p_~1~, _p_~2~, ... _p~N~_` is effectively equivalent to
  
  [source, cypher, subs="quotes"]
  ----
  WITH _PRE_PROJ_(_p_~1~), _PRE_PROJ_(_p_~2~), ..., _PRE_PROJ_(_p~N~_)
  WITH _AGGR_(_p_~1~), _AGGR_(_p_~2~), ..., _AGGR_(_p~N~_)
  RETURN _POST_PROJ_(_p_~1~), _POST_PROJ_(_p_~2~), ..., _POST_PROJ_(_p~N~_)
  ----
  
  Analogously, `WITH _p_~1~, _p_~2~, ... _p~N~_` is effectively equivalent to
  
  [source, cypher, subs="quotes"]
  ----
  WITH _PRE_PROJ_(_p_~1~), _PRE_PROJ_(_p_~2~), ..., _PRE_PROJ_(_p~N~_)
  WITH _AGGR_(_p_~1~), _AGGR_(_p_~2~), ..., _AGGR_(_p~N~_)
  WITH _POST_PROJ_(_p_~1~), _POST_PROJ_(_p_~2~), ..., _POST_PROJ_(_p~N~_)
  ----
  ====
  
  