anchor.diff:  
   The accompanying descending global sort order is the same order in reverse (i.e. it runs from `VOID` to `NODE`).
   
  -Any additional non-canonical types introduced by an implementation should be inserted between `PATH` and `STRING` in the global sort order. As an exception, any additional non-canonical types may be integrated under the other types in the global sort order if they are of a very similar nature (e.g. other number-like types, or other string-like types).
  -
  +[[equivalence-def,equivalence]]
   ==== Equivalence ====
   
   Equivalence remains mostly unchanged but now can be defined succinctly as being identical to equality except that:
   
   * Any two `null` values are equivalent (both directly or inside nested structures).
   * Any two `NaN` values are equivalent (both directly or inside nested structures).
  -* However, `null` and `NaN` values are not equivalent with each other.
  -
  -Equivalence is reflexive for all values.
  -
  +* However, `null` and `NaN` values are not equivalent (both directly or inside nested structures).
  +
  +<<equivalence-def,Equivalence>> is reflexive for all values.
  +
  +[[conceptual-model]]
   === Summary of the conceptual model ===
   
  -This proposal aims to simplify the conceptual model around equality, comparison, sorting, and grouping:
  -
  -- Comparability and equality are aligned with each other
  -  * Comparability: Two values of the same leaf type in the <<global-sort-order>> are comparable. Two values of different types are incomparable and values involving `null` are incomparable, too.
  +This proposal aims to simplify the conceptual model around equality, comparison, order, and grouping:
  +
  +- <<comparability-equality,Comparability and equality>> are aligned with each other
  +  * <<comparability-con,Comparability>> ensure that any two values of the same leaf type in the <<global-sort-order>> are comparable. Two values of different types are incomparable and values involving `null` are incomparable, too.
   This ensures that `MATCH (n) WHERE n.prop < 42` will never find nodes where `n.prop` is of type `STRING`.
  -  * Equality: Equality follows natural, literal equality. However, values involving `null` are never equal to any other value. Nested structures are first tested for equality by shape (keys, size) and then their corresponding elements are tested for equality pairwise. This ensures that equality is compatible with interpreting `null` as "unknown" or "could be any value" or "undefined".
  -- Orderability and equivalence are aligned with each other
  -  * Orderability follows comparability but additionally defines a <<global-sort-order>> between values of different types and is aligned with equivalence instead of equality, i.e. treats two `null` (resp. `NaN`) values as equivalent.
  -  * Equivalence: Equivalence is a form of equality that treats `null` (and `NaN`) values as the same value. Equivalence is used in grouping and `DISTINCT` where `null` commonly is interpreted as a category marker for results with missing values instead of as a wildcard for any possible value.
  +  * <<equality-con,Equality>> follows natural, literal equality. However, values involving `null` are never equal to any other value. Nested structures are first tested for equality by shape (keys, size) and then their corresponding elements are tested for equality pairwise. This ensures that equality is compatible with interpreting `null` as "unknown" or "could be any value" or "undefined".
  +- <<orderability-equivalence>> are aligned with each other
  +  * <<orderability-con,Orderability>> follows comparability but additionally defines a <<global-sort-order>> between values of different types and is aligned with equivalence instead of equality, i.e. treats two `null` (resp. `NaN`) values as equivalent.
  +  * <<equivalence-con,Equivalence>> is a form of equality that treats `null` (and `NaN`) values as the same value. Equivalence is used in grouping and `DISTINCT` where `null` commonly is interpreted as a category marker for results with missing values instead of as a wildcard for any possible value.
   
   === Examples
   
  
positive.code:   The difference between equality and equivalence in Cypher today is small and subtle, and limited to testing two instances of the value `null` to each other.
  
    ** In equality, `null = null` is `null`.
    ** In equivalence, used by `DISTINCT` and when grouping values, instances of `null` are always treated as being the same value.
    ** However, equality treats `null` values differently if they are an element of a list or a map value.
    ** Similar rules apply for `NaN`.
  
  Furthermore, the key concepts comparability, orderability, equality, and equivalence have never been defined properly.  Therefore another motivation for this CIP is to unambiguously and precisely define these 4 concepts.
  
  == Proposal
  
  We propose to redefine comparability and equality, as well as orderability and equivalence as detailed in this section.
  
  === Definitions
  
  Cypher today features four distinct notions related to equality and ordering:
  
  [horizontal]
  *Comparability*:: Comparability revolves around the inequality operators (`>`, `<`, `>=`, `\<=`), and defines the semantics they need to properly determine how two values compare to each other.
  *Equality*:: Equality revolves around the equality operators ('=', '<>') as well as the list membership operator (`IN`) and value joins, and defines the semantics the needed to properly determine if two values are the same.
  Equality is also used implicitly by literal maps in node and relationship patterns, since such literal maps are merely a shorthand notation for equality predicates.
  *Orderability*:: Orderability revolves around the `ORDER BY` clause, and defines the semantics it needs to be able to properly sort values passed to it.
  *Equivalence*:: Equivalence revolves around the `DISTINCT` modifier and grouping in projection clauses (`WITH`, `RETURN`), and defines the semantics they need to properly determine if two values are the same.
  
  === The meaning of `null`
  
  For the following discussion, it is helpful to clarify the meaning of `null`. In Cypher, a `null` value has one of two meanings, depending on the context in which it occurs:
  
  [horizontal]
  *Unknown*:: An "unknown" `null` is taken to be a placefolder for an arbitrary but unknown value. In the context of predicate expressions, an "unknown" `null` is the `maybe` truth value of ternary logic. For node and relationship properties, an "unknown" `null` is a value that is definite in the real world but has not been stored in the graph. Since in these cases, two "unknown" `null` values stand for arbitrary but definite values in the real world, two "unknown" `null` values should never be treated as certainly being the same value.
  *Missing*:: A "missing" `null` is taken to be a marker for the absence of a value. In the context of updating node properties from a map, a "missing" `null` is used to mark properties that are to be removed. In the context of `DISTINCT` and grouping, a "missing" `null` value is used as grouping key for all records that miss a more specific value. Since in these cases, two "missing" `null` values represent the same concept, they should always be treated as the same value.
  
  === Comparability and equality
  
  We propose that comparability and equality should be aligned with each other, i.e.
  
  `expr1 = expr2` if and only if `expr1 >= expr2 && expr1 \<= expr2`.
  
  ==== Incomparability
  
  In the context of both comparability and equality, `null` values should be interpreted as meaning "unknown" or "could be any value" or "undefined".
  
  We define that a value is incomparable if and only if any comparison or equality test involving this value evaluates to `null`.
  
  We define a pair of values to be incomparable if and only if any comparison or equality test between these two values evaluates to `null`.
  
  ==== Comparability
  
  We propose that comparability be defined between any pair of values, as specified below.
  
  - Numbers
    * Integers are compared numerically in ascending order.
  
negative.code: 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 maps>>
  ** `NODE`
  ** `RELATIONSHIP`
  * `LIST OF ANY?`
  