anchor.diff:  * Additionally, for each such key `k`,
   ** `m1.k = m2.k` is `true`.
   
  -As a consequence of these changes, plain equality is not reflexive for all values (consider: `{a: null} = {a: null}`, `[null] = [null]`). However this was already the case (consider: `null = null` \=> `null`).
  -
  -Note that equality is reflexive for values that do not involve `null` though.
  -
  +As a consequence of these changes, plain <<equality-def>> is not reflexive for all values (consider: `{a: null} = {a: null}`, `[null] = [null]`). However this was already the case (consider: `null = null` \=> `null`).
  +
  +Note that <<equality-def>> is reflexive for values that do not involve `null` though.
  +
  +[[orderability-equivalence]]
   === Orderability and equivalence ===
   
  -We propose that orderability and equivalence should be aligned with each other, i.e.
  +We propose that <<orderability-def>> and <<equivalence-def>> should be aligned with each other, i.e.
   
   `expr1` is equivalent to `expr2` if and only if they would be sorted before (or after resp.) any other non-equivalent value in the same way (i.e. they have the same position under orderability).
   
  -In the context of both orderability and equivalence, `null` values should be interpreted as a category marker for "missing value".
  -
  +Orderability and equivalence use <<missing-null,"missing" `null` values>>.
  +
  +[[orderability-def,orderability]]
   ==== Orderability ====
   
   [[global-sort-order,global sort order]]
  
positive.code: Furthermore, Cypher has good semantics for comparability and orderability for integers, floats, and strings, within each of the types.
  However working with values of different types can be difficult:
  
    * Comparability between values of different types is often undefined, which is something we regard as a problem for certain combinations of values and types.
    * `ORDER BY` will often fail with an error if the values passed to it have different types.
  
  2. The underlying conceptual model is complex and sometimes inconsistent. This leads to an unclear relationship between comparison operators, equality, grouping, and `ORDER BY`:
  
negative.code: 
  .Comparability of values of different types (`X` means the result of comparison will always return `true` or `false`)
  [frame="topbot",options="header,footer"]
  |================================================================================================================================
  |Type           | `NODE` | `RELATIONSHIP` | `PATH` | `MAP` | `LIST OF ANY?` | `STRING` | `BOOLEAN` | `INTEGER` | `FLOAT` | `VOID`
  |`NODE`         | X      |                |        |       |                |          |           |           |         |
  |`RELATIONSHIP` |        | X              |        |       |                |          |           |           |         |
  |`PATH`         |        |                | X      |       |                |          |           |           |         |
  |`MAP`          |        |                |        | X     |                |          |           |           |         |
  |`LIST OF ANY?` |        |                |        |       | X              |          |           |           |         |
  |`STRING`       |        |                |        |       |                | X        |           |           |         |
  |`BOOLEAN`      |        |                |        |       |                |          | X         |           |         |
  |`INTEGER`      |        |                |        |       |                |          |           | X         | X       |
  |`FLOAT`        |        |                |        |       |                |          |           | X         | X       |
  |`VOID`         |        |                |        |       |                |          |           |           |         |
  |================================================================================================================================
  `
  