anchor.diff:  The truth tables for the boolean operators `NOT`, `AND` and `OR` are given below.
   The `XOR` in Cypher is defined by these basic operators as `a XOR b = (a AND NOT(b)) OR (NOT(a) AND b)`.
   
  -*Negation*
  +[[negation,negation]]
  +.Negation
   [width="50%",options="header"]
   |===========
   |a    |NOT a
  
positive.code: [[equality-def,equality]]
  ==== Equality ====
  
  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)
  ---
  
  ===== Map equality =====
  
  
negative.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 example, `{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.
  