anchor.diff:              gen {
                   let chooseSqrtOfSize = Gen.choose(0, n |> float |> sqrt |> sqrt |> int)
                   let! N = chooseSqrtOfSize
  -                let! M = chooseSqrtOfSize
  -                let! K = chooseSqrtOfSize
  -                let! L = chooseSqrtOfSize
  +                let! M = chooseSqrtOfSize |> Gen.map (zeroIfZero N)
  +                let! K = chooseSqrtOfSize |> Gen.map (zeroIfZero M)
  +                let! L = chooseSqrtOfSize |> Gen.map (zeroIfZero K)
                   let g = Arb.generate<'T>
                   let! seed = Gen.arrayOfLength (N*M*K*L) g
                   return Array4D.init N M K L (fun n m k l -> seed.[n + m * N + k * N * M + l * N * M * K])
  
positive.code: 
          Arb.fromGen (genTy ())
  
      static member Array3D<'T> () =
          let mkSized (n : int) =
              gen {
                  // sqrt is good enough here
                  let chooseSqrtOfSize = Gen.choose(0, n |> float |> sqrt |> int)
                  let! N = chooseSqrtOfSize
                  let! M = chooseSqrtOfSize
                  let! K = chooseSqrtOfSize
                  let g = Arb.generate<'T>
                  let! seed = Gen.arrayOfLength (N*M*K) g
                  return Array3D.init N M K (fun n m k -> seed.[n + m * N + k * N * M])
  
negative.code:         |]
  
      static let timeZones = TimeZoneInfo.GetSystemTimeZones() |> Seq.toArray
      static let zeroIfZero n v = if n = 0 then 0 else v
  
      static member TimeZoneInfo = Arb.generate<int> |> Gen.map (fun i -> timeZones.[abs i % timeZones.Length]) |> Arb.fromGen
      static member BigInt = Arb.generate<byte []> |> Gen.map (fun bs -> System.Numerics.BigInteger(bs)) |> Arb.fromGen
      
      static member Type =
          let rec genTy () = gen {
              let! i = Arb.generate<int>
  