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: Cypher today features four distinct concepts related to equality and ordering:
  
  [horizontal]
  [[comparability-con,comparability (concept)]]*Comparability*:: <<comparability-def,Comparability>> revolves around the inequality operators (`>`, `<`, `>=`, `\<=`), and defines the semantics they need to properly determine how two values compare to each other.
  [[equality-con,equality (concept)]]*Equality*:: <<equality-def,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-con,orderability (concept)]]*Orderability*:: <<orderability-def,Orderability>> revolves around the `ORDER BY` clause, and defines the semantics it needs to be able to properly sort values passed to it.
  [[equivalence-con,equivalence (concept)]]*Equivalence*:: <<equivalence-def,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-null,unknown `null`]]*Unknown*:: An "unknown" `null` is taken to be a placefolder for an arbitrary but unknown value. When evaluating predicates, 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-null,missing `null`]]*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.
  
  [[regular-maps]]
  ==== Regular maps
  
  Cypher today has one supertype `MAP` for all map values. This includes nodes (of subtype `NODE`), relationships (of subtype `RELATIONSHIP`), and any other map (not captured by a subtype of `MAP`). For the purpose of this document, we define a regular map to be any value of type `MAP` that is neither a `NODE` nor a `RELATIONSHIP`.
  
negative.code: A string compared to a boolean
  [source, cypher]
  ----
  RETURN 'string' <= true // should be null
  ----
  
  Ordering values of different types
  