(Map? ∪ (singleton _ _ )) where Map? = m0:                                              OK
      (List? ∪ (singleton _ _ )) where Map? = m0:                                             OK
      (70 ∉ (dom Map?)) where Map? = m0:                                                      OK
      (((dom Map?) ◁ Map?) ▷ (dom Map?)) where Map? = ((dom stkcred) ◁ deleg) ▷ (dom stpool): OK
      (List? ⋫ Set?) where Map? = Range exclude 1:                                            OK
      (List? ⋫ Single?) where Map? = Range exclude 2:                                         OK
      (List? ⋫ Set?) where Map? = Range exclude 3:                                            OK
      ((Set? ⋪ Map?) ∪ Map?) where Map? = DomExclude Union:                                   OK
      (Set? ➖ (dom Map?)) where Map? = Set difference:                                       OK
      compute and runSet of (((dom Map?) ◁ Map?) ▷ (dom Map?)) are the same:                  OK
      compute and runSet of (List? ⋫ Set?) are the same:                                      OK
      compute and runSet of (Map? ∪ (singleton _ _ )) are the same:                           OK
      compute and runSet of ((setSingleton _ ) ⋪ Map?) are the same:                          OK
      (5 ∈ (dom Map?)) where Map? = ex1:                                                      OK
      (70 ∈ (dom Map?)) where Map? = ex2:                                                     OK
      (70 ∉ (dom Map?)) where Map? = ex3:                                                     OK
      (Map? ∪ (singleton _ _ )) where Map? = ex4:                                             OK
      ((setSingleton _ ) ⋪ Map?) where Map? = ex5:                                            OK
      ((dom (singleton _ _ )) ⋪ Map?) where Map? = ex6:                                       OK
      ((rng (singleton _ _ )) ⋪ Map?) where Map? = ex7:                                       OK
      (Set? ➖ (dom Map?)) where Map? = ex8:                                                  OK
    keysEqual tests
      keysEqual 1:                                                                            OK
      keysEqual 2:                                                                            OK
      keysEqual 3:                                                                            OK
      keysEqual 4:                                                                            OK
      keysEqual 5:                                                                            OK
      keysEqual 6:                                                                            OK
      keysEqual 7:                                                                            OK
      keysEqual 8:                                                                            OK
      keysEqual 9:                                                                            OK
      keysEqual 10:                                                                           OK
    Iterator tests
      (And l1 l2) as List, fifo:                                                              OK
      (And l1 l2) as Map, fifo:                                                               OK
      (And l1 l2) as List, lifo:                                                              OK
      (And l1 l2) as Map, lifo:                                                               OK
      (Or l1 l2) as List:                                                                     OK
      (Or l1 l2) as Map:                                                                      OK
      (Diff l1 l2) as List:                                                                   OK
      (Diff l2 l1) as List:                                                                   OK
      (Diff l1 l2) as Map:                                                                    OK
      (Diff l2 l1) as Map:                                                                    OK
      (Guard l1 even) as List:                                                                OK
      (Guard l1 even) as Map:                                                                 OK
      (Guard l2 even) as List:                                                                OK
      (Guard l2 even) as Map:                                                                 OK
      (Proj l1 ord) as List:                                                                  OK
      (Proj l1 ord) as Map:                                                                   OK
      (Proj l2 ord) as List:                                                                  OK
      (Proj l2 ord) as Map:                                                                   OK
      (AndP l1:List l3:Map ord):                                                              OK
      (AndP l1:Map l3:List ord):                                                              OK
      (AndP l1:Map l3:List Map):                                                              OK
      (Chain l4:List l5:Map):                                                                 OK
      (Chain l4:Map l5:List):                                                                 OK
      (Chain l4:Map l5:List Map):                                                             OK
      (Chain2 l5:List l4:Map):                                                                OK
      (Chain2 l5:Map l4:List):                                                                OK
      (Chain2 l5:Map l4:List Map):                                                            OK
      Epoch Boundary Example:                                                                 OK
    intersect2ways:                                                                           OK
      +++ OK, passed 100 tests.
    ledgerStateExample2ways:                                                                  OK
      +++ OK, passed 100 tests.
    eval-materialize-intersectDom:                                                            OK
      +++ OK, passed 100 tests.
    slowFastEquiv:                                                                            OK (0.05s)
      +++ OK, passed 100 tests.
  RelationTests - check conformance with the original implementation
    dom:                                                                                      OK
      +++ OK, passed 100 tests.
    range:                                                                                    OK
      +++ OK, passed 100 tests.
    ∈:                                                                                        OK
      +++ OK, passed 100 tests.
    ∉:                                                                                        OK
      +++ OK, passed 100 tests.
    haskey:                                                                                   OK
      +++ OK, passed 100 tests.
    ◁:                                                                                        OK
      +++ OK, passed 100 tests.
    ⋪:                                                                                        OK
      +++ OK, passed 100 tests.
    ▷:                                                                                        OK
      +++ OK, passed 100 tests.
    ⋫:                                                                                        OK
      +++ OK, passed 100 tests.
    ∪:                                                                                        OK
      +++ OK, passed 100 tests.
    ⨃:                                                                                        OK
      +++ OK, passed 100 tests.
    ∪+:                                                                                       OK
      +++ OK, passed 100 tests.
    ⊆:                                                                                        OK
      +++ OK, passed 100 tests.
    ∩:                                                                                        OK
      +++ OK, passed 100 tests.

All 83 tests passed (0.11s)