anchor.diff:          |> Array.distinct
           |> Array.sort
   
  +    let subSetsCount (disjointSet: DisjointSet) : int = 
  +        subSets disjointSet |> Array.length 
  +
       let sizeOnePlusCondition (disjointSet: DisjointSet) : bool =
           DisjointSet.size disjointSet > 0
   
       let hasOnePlusSubSets (disjointSet: DisjointSet) : bool = 
  -        let sets = subSets disjointSet
  -        let setsCount = Array.length sets
  +        let setsCount = subSetsCount disjointSet
           let size = DisjointSet.size disjointSet
           setsCount >= 1 && setsCount <= size        
   
  
positive.code:             fun (disjointSet: DisjointSet) ->
                  not (sizeOnePlusCondition disjointSet) || hasOnePlusSubSets disjointSet
  
          testPropertyWithConfig {Config.Quick with MaxTest=250} 
              "An increase size operation updates size to be max (size newSize) - never a smaller size" <|
              fun (disjointSet: DisjointSet) (newSize: uint32) ->
                  let sizeInitial = DisjointSet.size disjointSet
                  DisjointSet.increaseSize disjointSet (Size newSize)
  
negative.code:             fun (disjointSet: DisjointSet) (newSize: uint32) ->
                  let mappings = subSetMappings disjointSet                                             
                  DisjointSet.increaseSize disjointSet (Size newSize)                
                  let mappingsUpdated = subSetMappings disjointSet
                  
                  mappings = Array.take (Array.length mappings) mappingsUpdated
  
          testPropertyWithConfig {Config.Quick with MaxTest=250}
              "An increase size operation adds a new subset for each increase in the valid EntryId range." <|
              fun (disjointSet: DisjointSet) (newSize: uint32) ->
                  let sizeInitial = DisjointSet.size disjointSet
                  let setsCountIntial = subSetsCount disjointSet
  
                  DisjointSet.increaseSize disjointSet (Size newSize)
  
                  let sizeUpdated = DisjointSet.size disjointSet     
                  let setsCountUpdated = subSetsCount disjointSet            
                  let sizeDiff = sizeUpdated - sizeInitial
                  let setsCountDiff = setsCountUpdated - setsCountIntial
  
                  setsCountDiff = sizeDiff
  
          testPropertyWithConfig {Config.Quick with MaxTest=250} 
              "Union operations fail when out of range and succeed otherwise" <|
              fun (disjointSet: DisjointSet) (u1: EntryId) (u2: EntryId) ->
                  let size = DisjointSet.size disjointSet
                  let result = DisjointSet.union disjointSet u1 u2
                  let shouldSucceed = (int u1.Index) < size && (int u2.Index) < size
  
                  shouldSucceed <> failed result
  
          testPropertyWithConfig {Config.Quick with MaxTest=250} 
              "Find operations fail when out of range and succeed otherwise" <|
              fun (disjointSet: DisjointSet) (e1: EntryId) ->
                  let size = DisjointSet.size disjointSet
                  let result = DisjointSet.find disjointSet e1
                  let shouldSucceed = (int e1.Index) < size
  
                  shouldSucceed <> failed result
                  
          testPropertyWithConfig {Config.Quick with MaxTest=250} 
              "inSameSubset operations fail when out of range and succeed otherwise" <|
              fun (disjointSet: DisjointSet) (e1: EntryId) (e2: EntryId) ->
                  let size = DisjointSet.size disjointSet
                  let result = DisjointSet.inSameSubset disjointSet e1 e2
                  let shouldSucceed = (int e1.Index) < size && (int e2.Index) < size
  
                  shouldSucceed <> failed result      
  
          testPropertyWithConfig {Config.Quick with MaxTest=250}
              "Out of range failed find, union and inSameSubset operations do not change the disjoint set." <|
  