anchor.diff:  [[equality-def,equality]]
   ==== Equality ====
   
  +Given that values are only comparable within their most specific type, and comparability and equality are tied together, equlity of values of different types always evaluates to `null`.
   In order to align equality with <<comparability-def>>, we change equality of lists and maps that contain `null` values to treat those values in the same way as if they would have been compared outside of those lists and maps, as individual, simple values.
   
   ===== List equality =====
   
   Specifically, we propose to redefine how equality works for lists in Cypher.
  -To determine if two lists `l1` and `l2` are equal, we propose two simple tests, as exemplified by the following:
  -
  -* `l1` and `l2` must have the same size, i.e. inversely `size(l1) <> size(l2) \=> l1 <> l2`. This also applies when any of the lists contains null, i.e. `[a1, a2, ..., an] = [b1, b2, ..., null, ..., bm]` evaluates to false if `m <> n`.
  -* the pairwise elements of both `l1` and `l2` must be equal, i.e.
  -----
  -[a1, a2, ..., an] = [b1, b2, ..., bn]
  -<=>
  -a1 = b1 && a2 = b2 && ... && an = bn
  -----
  -* If the second test evaluates to `null`, these lists are <<incomparable>>. This will only happen if at least one element in one of the lists is `null` while all non-null elements are pairwise equal. For example, `[1, 2] = [1, null]` evaluates to `null` (incomparable), while `[1, 2] = [null, 'foo']` evaluates to `false`.
  -* For nested lists, the two tests above are carried out recursively, i.e.
  ----
  -[[1]] = [[1], [null]] evaluates to false
  -[[1, 2], [1, 3]] = [[1, 2], [null, 'foo']] evaluates to false
  -[[1, 2], ['foo', 'bar']] = [[1, 2], [null, 'bar']] evaluates to null (incomparable)
  ----
  +The equality of two lists `a` and `b` is defined is the <<conjunction>> of `size(a) = size(b)` and a pairwise comparison of all elements of the list.
  +If `a = b` evaluates to `null` these lists are <<incomparable>>.
  +
  +In the following example `=>` means "evaluates to".
  +----
  +[1, 2] = [1]
  +    => size([1, 2]) = size([1]) AND 1 = 1 AND 2 = null
  +    => false                    AND true  AND null
  +    => false
  +
  +[null] = [1]
  +    => size([null]) = size[1]) AND null = 1
  +    => true                    AND null
  +    => null
  +
  +["a"] = [1]
  +    => size(["a"]) = size[1]) AND "a" = 1
  +    => true                   AND null
  +    => null
  +----
  +
  +The same logic applies recursively when comparing nested lists.
  +----
  +[[1]] = [[1], [null]]
  +    => size([[1]]) = size([[1], [null]]) AND [1] = [1] AND null = [null]
  +    => false                             AND true      AND null
  +    => false
  +----
   
   ===== Map equality =====
   
  
positive.code:   ** The comparison order for maps is unspecified and left to implementations.
    ** The comparison order for maps must align with the <<equality-def,equality semantics>> outlined below.
    In consequence, any map that contains an entry that maps its key to a `null` value is <<incomparable>>.
    For exampe, `{a: 1} \<= {a: 1, b: null}` evaluates to `null`.
    ** Regular maps are <<incomparable>> to any value that is not also a regular map.
    * Nodes
    ** The comparison order for nodes is based on an implementation specific internal total order of node identities.
  
negative.code: |false|true
  |===========
  
  [[conjunction,conjunction]]
  .Conjunction
  [width="50%",options="header"]
  |===================
  |a    |b    |a AND B
  