anchor.diff:  
   This proposal could be extended with an operator for making equivalence accessible beyond use in grouping and `DISTINCT`. This seems desirable due to the equality operator (`=`) not being reflexive for all values.
   
  -Also noteworthy: If <<unknown-null,unknown `null` values>> would track their source, equality could become reflexive again as it would become possible to know if two `null` values represent the same "unknown" value.
  +This CIP introduces the distinction between "unknown" and "missing" `null` values. A future proposal could investigate making this explicit through the introduction of different kinds of `null` values. If such a change would be adopted and <<unknown-null,unknown `null` values>> would track their source, equality could become reflexive again as it would become possible to know if two `null` values represent the same "unknown" value. However, this would not remove the need to distinguish between equality and equivalence as grouping would still require `missing = unknown => true` while in general `missing = unknown => missing`.
   
   == Benefits to this proposal
   
  
positive.code: [abstract]
  .Abstract
  --
  This CIP redefines and formalizes 4 key lanugage concepts, *comparability* and *equality*, as well as *orderability* and *equivalence*. While these notions already exist in the language today, they have never been defined explicitly.
  Furthermore the current definitions are somewhat misaligned with each other. This leads to inconsistencies and an unnecessarily complicated conceptual model. In summary, this CIP proposes some changes to how Cypher defines these four concepts in order to get a consistent set of rules and also proposes to align comparability with equality, as well as orderability with equivalence to provide a simpler conceptual model.
  --
  
  toc::[]
  
negative.code: ==== Orderability ====
  
  [[global-sort-order,global sort order]]
  We propose that orderability be defined between any pair of values, where the result is always `true` or `false`.
  
  To accomplish this, there must be a pre-determined order of types and each value must fall under exactly one disjoint leaf type in this order. We propose to use the following ascending global sort order of disjoint types:
  
  * `MAP` types
  ** <<regular-map,Regular map>>
  ** `NODE`
  ** `RELATIONSHIP`
  * `LIST OF ANY?`
  * `PATH`
  * `STRING`
  * `BOOLEAN`
  * `NUMBER`
  ** `NaN` is treated as the largest number in orderability only (i.e. it is put after positive infinity)
  * `VOID` (i.e. the type of `null`)
  
  To give a concrete example, under this global sort order all nodes come before all strings.
  
  Between values of the same type in the global sort order, orderability defers to comparability except that equality is overriden by equivalence as described below.
  
  The accompanying descending global sort order is the same order in reverse (i.e. it runs from `VOID` to `MAP`).
  
  [[equivalence-def,equivalence]]
  ==== Equivalence ====
  