File: .lake/packages/batteries/Batteries/Data/UInt.lean

full_name: UInt8.ext
code: @[ext] theorem UInt8.ext : {x y : UInt8} → x.toNat = y.toNat → x = y
  
goal: x.toNat = y.toNat → x = y

full_name: UInt8.ext_iff
code: theorem UInt8.ext_iff {x y : UInt8} : x = y ↔ x.toNat = y.toNat 
goal: x = y ↔ x.toNat = y.toNat

full_name: UInt8.val_val_eq_toNat
code: @[simp] theorem UInt8.val_val_eq_toNat (x : UInt8) : x.val.val = x.toNat 
goal: ↑x.val = x.toNat

full_name: UInt8.val_ofNat
code: @[simp] theorem UInt8.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt8).val = OfNat.ofNat n 
goal: (OfNat.ofNat n).val = OfNat.ofNat n

full_name: UInt8.toNat_ofNat
code: @[simp] theorem UInt8.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt8).toNat = n % UInt8.size 
goal: (OfNat.ofNat n).toNat = n % UInt8.size

full_name: UInt8.toNat_lt
code: theorem UInt8.toNat_lt (x : UInt8) : x.toNat < 2 ^ 8 
goal: x.toNat < 2 ^ 8

full_name: UInt8.toUInt16_toNat
code: @[simp] theorem UInt8.toUInt16_toNat (x : UInt8) : x.toUInt16.toNat = x.toNat 
goal: x.toUInt16.toNat = x.toNat

full_name: UInt8.toUInt32_toNat
code: @[simp] theorem UInt8.toUInt32_toNat (x : UInt8) : x.toUInt32.toNat = x.toNat 
goal: x.toUInt32.toNat = x.toNat

full_name: UInt8.toUInt64_toNat
code: @[simp] theorem UInt8.toUInt64_toNat (x : UInt8) : x.toUInt64.toNat = x.toNat 
goal: x.toUInt64.toNat = x.toNat

full_name: UInt8.toNat_zero
code: theorem UInt8.toNat_zero : (0 : UInt8).toNat = 0 
goal: UInt8.toNat 0 = 0

full_name: UInt8.toNat_add
code: theorem UInt8.toNat_add (x y : UInt8) : (x + y).toNat = (x.toNat + y.toNat) % UInt8.size 
goal: (x + y).toNat = (x.toNat + y.toNat) % UInt8.size

full_name: UInt8.toNat_sub
code: theorem UInt8.toNat_sub (x y : UInt8) :
    (x - y).toNat = (UInt8.size - y.toNat + x.toNat) % UInt8.size 
goal: (x - y).toNat = (UInt8.size - y.toNat + x.toNat) % UInt8.size

full_name: UInt8.toNat_mul
code: theorem UInt8.toNat_mul (x y : UInt8) : (x * y).toNat = (x.toNat * y.toNat) % UInt8.size 
goal: (x * y).toNat = x.toNat * y.toNat % UInt8.size

full_name: UInt8.toNat_div
code: theorem UInt8.toNat_div (x y : UInt8) : (x / y).toNat = x.toNat / y.toNat 
goal: (x / y).toNat = x.toNat / y.toNat

full_name: UInt8.toNat_mod
code: theorem UInt8.toNat_mod (x y : UInt8) : (x % y).toNat = x.toNat % y.toNat 
goal: (x % y).toNat = x.toNat % y.toNat

full_name: UInt8.toNat_modn
code: theorem UInt8.toNat_modn (x : UInt8) (n) : (x.modn n).toNat = x.toNat % n 
goal: (x.modn n).toNat = x.toNat % n

full_name: UInt8.le_antisymm_iff
code: theorem UInt8.le_antisymm_iff {x y : UInt8} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: UInt8.le_antisymm
code: theorem UInt8.le_antisymm {x y : UInt8} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdUInt8_.lake»
code: instance : Batteries.LawfulOrd UInt8 
goal: Batteries.LawfulOrd UInt8

full_name: UInt16.ext
code: @[ext] theorem UInt16.ext : {x y : UInt16} → x.toNat = y.toNat → x = y
  
goal: x.toNat = y.toNat → x = y

full_name: UInt16.ext_iff
code: theorem UInt16.ext_iff {x y : UInt16} : x = y ↔ x.toNat = y.toNat 
goal: x = y ↔ x.toNat = y.toNat

full_name: UInt16.val_val_eq_toNat
code: @[simp] theorem UInt16.val_val_eq_toNat (x : UInt16) : x.val.val = x.toNat 
goal: ↑x.val = x.toNat

full_name: UInt16.val_ofNat
code: @[simp] theorem UInt16.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt16).val = OfNat.ofNat n 
goal: (OfNat.ofNat n).val = OfNat.ofNat n

full_name: UInt16.toNat_ofNat
code: @[simp] theorem UInt16.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt16).toNat = n % UInt16.size 
goal: (OfNat.ofNat n).toNat = n % UInt16.size

full_name: UInt16.toNat_lt
code: theorem UInt16.toNat_lt (x : UInt16) : x.toNat < 2 ^ 16 
goal: x.toNat < 2 ^ 16

full_name: UInt16.toUInt8_toNat
code: @[simp] theorem UInt16.toUInt8_toNat (x : UInt16) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
goal: x.toUInt8.toNat = x.toNat % 2 ^ 8

full_name: UInt16.toUInt32_toNat
code: @[simp] theorem UInt16.toUInt32_toNat (x : UInt16) : x.toUInt32.toNat = x.toNat 
goal: x.toUInt32.toNat = x.toNat

full_name: UInt16.toUInt64_toNat
code: @[simp] theorem UInt16.toUInt64_toNat (x : UInt16) : x.toUInt64.toNat = x.toNat 
goal: x.toUInt64.toNat = x.toNat

full_name: UInt16.toNat_zero
code: theorem UInt16.toNat_zero : (0 : UInt16).toNat = 0 
goal: UInt16.toNat 0 = 0

full_name: UInt16.toNat_add
code: theorem UInt16.toNat_add (x y : UInt16) : (x + y).toNat = (x.toNat + y.toNat) % UInt16.size 
goal: (x + y).toNat = (x.toNat + y.toNat) % UInt16.size

full_name: UInt16.toNat_sub
code: theorem UInt16.toNat_sub (x y : UInt16) :
    (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size 
goal: (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size

full_name: UInt16.toNat_mul
code: theorem UInt16.toNat_mul (x y : UInt16) : (x * y).toNat = (x.toNat * y.toNat) % UInt16.size 
goal: (x * y).toNat = x.toNat * y.toNat % UInt16.size

full_name: UInt16.toNat_div
code: theorem UInt16.toNat_div (x y : UInt16) : (x / y).toNat = x.toNat / y.toNat 
goal: (x / y).toNat = x.toNat / y.toNat

full_name: UInt16.toNat_mod
code: theorem UInt16.toNat_mod (x y : UInt16) : (x % y).toNat = x.toNat % y.toNat 
goal: (x % y).toNat = x.toNat % y.toNat

full_name: UInt16.toNat_modn
code: theorem UInt16.toNat_modn (x : UInt16) (n) : (x.modn n).toNat = x.toNat % n 
goal: (x.modn n).toNat = x.toNat % n

full_name: UInt16.le_antisymm_iff
code: theorem UInt16.le_antisymm_iff {x y : UInt16} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: UInt16.le_antisymm
code: theorem UInt16.le_antisymm {x y : UInt16} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdUInt16_.lake»
code: instance : Batteries.LawfulOrd UInt16 
goal: Batteries.LawfulOrd UInt16

full_name: UInt32.ext
code: @[ext] theorem UInt32.ext : {x y : UInt32} → x.toNat = y.toNat → x = y
  
goal: x.toNat = y.toNat → x = y

full_name: UInt32.ext_iff
code: theorem UInt32.ext_iff {x y : UInt32} : x = y ↔ x.toNat = y.toNat 
goal: x = y ↔ x.toNat = y.toNat

full_name: UInt32.val_val_eq_toNat
code: @[simp] theorem UInt32.val_val_eq_toNat (x : UInt32) : x.val.val = x.toNat 
goal: ↑x.val = x.toNat

full_name: UInt32.val_ofNat
code: @[simp] theorem UInt32.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).val = OfNat.ofNat n 
goal: (OfNat.ofNat n).val = OfNat.ofNat n

full_name: UInt32.toNat_ofNat
code: @[simp] theorem UInt32.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).toNat = n % UInt32.size 
goal: (OfNat.ofNat n).toNat = n % UInt32.size

full_name: UInt32.toNat_lt
code: theorem UInt32.toNat_lt (x : UInt32) : x.toNat < 2 ^ 32 
goal: x.toNat < 2 ^ 32

full_name: UInt32.toUInt8_toNat
code: @[simp] theorem UInt32.toUInt8_toNat (x : UInt32) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
goal: x.toUInt8.toNat = x.toNat % 2 ^ 8

full_name: UInt32.toUInt16_toNat
code: @[simp] theorem UInt32.toUInt16_toNat (x : UInt32) : x.toUInt16.toNat = x.toNat % 2 ^ 16 
goal: x.toUInt16.toNat = x.toNat % 2 ^ 16

full_name: UInt32.toUInt64_toNat
code: @[simp] theorem UInt32.toUInt64_toNat (x : UInt32) : x.toUInt64.toNat = x.toNat 
goal: x.toUInt64.toNat = x.toNat

full_name: UInt32.toNat_zero
code: theorem UInt32.toNat_zero : (0 : UInt32).toNat = 0 
goal: UInt32.toNat 0 = 0

full_name: UInt32.toNat_add
code: theorem UInt32.toNat_add (x y : UInt32) : (x + y).toNat = (x.toNat + y.toNat) % UInt32.size 
goal: (x + y).toNat = (x.toNat + y.toNat) % UInt32.size

full_name: UInt32.toNat_sub
code: theorem UInt32.toNat_sub (x y : UInt32) :
    (x - y).toNat = (UInt32.size - y.toNat + x.toNat) % UInt32.size 
goal: (x - y).toNat = (UInt32.size - y.toNat + x.toNat) % UInt32.size

full_name: UInt32.toNat_mul
code: theorem UInt32.toNat_mul (x y : UInt32) : (x * y).toNat = (x.toNat * y.toNat) % UInt32.size 
goal: (x * y).toNat = x.toNat * y.toNat % UInt32.size

full_name: UInt32.toNat_div
code: theorem UInt32.toNat_div (x y : UInt32) : (x / y).toNat = x.toNat / y.toNat 
goal: (x / y).toNat = x.toNat / y.toNat

full_name: UInt32.toNat_mod
code: theorem UInt32.toNat_mod (x y : UInt32) : (x % y).toNat = x.toNat % y.toNat 
goal: (x % y).toNat = x.toNat % y.toNat

full_name: UInt32.toNat_modn
code: theorem UInt32.toNat_modn (x : UInt32) (n) : (x.modn n).toNat = x.toNat % n 
goal: (x.modn n).toNat = x.toNat % n

full_name: UInt32.le_antisymm_iff
code: theorem UInt32.le_antisymm_iff {x y : UInt32} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: UInt32.le_antisymm
code: theorem UInt32.le_antisymm {x y : UInt32} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdUInt32_.lake»
code: instance : Batteries.LawfulOrd UInt32 
goal: Batteries.LawfulOrd UInt32

full_name: UInt64.ext
code: @[ext] theorem UInt64.ext : {x y : UInt64} → x.toNat = y.toNat → x = y
  
goal: x.toNat = y.toNat → x = y

full_name: UInt64.ext_iff
code: theorem UInt64.ext_iff {x y : UInt64} : x = y ↔ x.toNat = y.toNat 
goal: x = y ↔ x.toNat = y.toNat

full_name: UInt64.val_val_eq_toNat
code: @[simp] theorem UInt64.val_val_eq_toNat (x : UInt64) : x.val.val = x.toNat 
goal: ↑x.val = x.toNat

full_name: UInt64.val_ofNat
code: @[simp] theorem UInt64.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt64).val = OfNat.ofNat n 
goal: (OfNat.ofNat n).val = OfNat.ofNat n

full_name: UInt64.toNat_ofNat
code: @[simp] theorem UInt64.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt64).toNat = n % UInt64.size 
goal: (OfNat.ofNat n).toNat = n % UInt64.size

full_name: UInt64.toNat_lt
code: theorem UInt64.toNat_lt (x : UInt64) : x.toNat < 2 ^ 64 
goal: x.toNat < 2 ^ 64

full_name: UInt64.toUInt8_toNat
code: @[simp] theorem UInt64.toUInt8_toNat (x : UInt64) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
goal: x.toUInt8.toNat = x.toNat % 2 ^ 8

full_name: UInt64.toUInt16_toNat
code: @[simp] theorem UInt64.toUInt16_toNat (x : UInt64) : x.toUInt16.toNat = x.toNat % 2 ^ 16 
goal: x.toUInt16.toNat = x.toNat % 2 ^ 16

full_name: UInt64.toUInt32_toNat
code: @[simp] theorem UInt64.toUInt32_toNat (x : UInt64) : x.toUInt32.toNat = x.toNat % 2 ^ 32 
goal: x.toUInt32.toNat = x.toNat % 2 ^ 32

full_name: UInt64.toNat_zero
code: theorem UInt64.toNat_zero : (0 : UInt64).toNat = 0 
goal: UInt64.toNat 0 = 0

full_name: UInt64.toNat_add
code: theorem UInt64.toNat_add (x y : UInt64) : (x + y).toNat = (x.toNat + y.toNat) % UInt64.size 
goal: (x + y).toNat = (x.toNat + y.toNat) % UInt64.size

full_name: UInt64.toNat_sub
code: theorem UInt64.toNat_sub (x y : UInt64) :
    (x - y).toNat = (UInt64.size - y.toNat + x.toNat) % UInt64.size 
goal: (x - y).toNat = (UInt64.size - y.toNat + x.toNat) % UInt64.size

full_name: UInt64.toNat_mul
code: theorem UInt64.toNat_mul (x y : UInt64) : (x * y).toNat = (x.toNat * y.toNat) % UInt64.size 
goal: (x * y).toNat = x.toNat * y.toNat % UInt64.size

full_name: UInt64.toNat_div
code: theorem UInt64.toNat_div (x y : UInt64) : (x / y).toNat = x.toNat / y.toNat 
goal: (x / y).toNat = x.toNat / y.toNat

full_name: UInt64.toNat_mod
code: theorem UInt64.toNat_mod (x y : UInt64) : (x % y).toNat = x.toNat % y.toNat 
goal: (x % y).toNat = x.toNat % y.toNat

full_name: UInt64.toNat_modn
code: theorem UInt64.toNat_modn (x : UInt64) (n) : (x.modn n).toNat = x.toNat % n 
goal: (x.modn n).toNat = x.toNat % n

full_name: UInt64.le_antisymm_iff
code: theorem UInt64.le_antisymm_iff {x y : UInt64} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: UInt64.le_antisymm
code: theorem UInt64.le_antisymm {x y : UInt64} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdUInt64_.lake»
code: instance : Batteries.LawfulOrd UInt64 
goal: Batteries.LawfulOrd UInt64

full_name: USize.ext
code: @[ext] theorem USize.ext : {x y : USize} → x.toNat = y.toNat → x = y
  
goal: x.toNat = y.toNat → x = y

full_name: USize.ext_iff
code: theorem USize.ext_iff {x y : USize} : x = y ↔ x.toNat = y.toNat 
goal: x = y ↔ x.toNat = y.toNat

full_name: USize.val_val_eq_toNat
code: @[simp] theorem USize.val_val_eq_toNat (x : USize) : x.val.val = x.toNat 
goal: ↑x.val = x.toNat

full_name: USize.val_ofNat
code: @[simp] theorem USize.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : USize).val = OfNat.ofNat n 
goal: (OfNat.ofNat n).val = OfNat.ofNat n

full_name: USize.toNat_ofNat
code: @[simp] theorem USize.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : USize).toNat = n % USize.size 
goal: (OfNat.ofNat n).toNat = n % USize.size

full_name: USize.size_eq
code: theorem USize.size_eq : USize.size = 2 ^ System.Platform.numBits 
goal: USize.size = 2 ^ System.Platform.numBits

full_name: USize.le_size
code: theorem USize.le_size : 2 ^ 32 ≤ USize.size 
goal: 2 ^ 32 ≤ USize.size

full_name: USize.size_le
code: theorem USize.size_le : USize.size ≤ 2 ^ 64 
goal: USize.size ≤ 2 ^ 64

full_name: USize.toNat_lt
code: theorem USize.toNat_lt (x : USize) : x.toNat < 2 ^ System.Platform.numBits 
goal: x.toNat < 2 ^ System.Platform.numBits

full_name: USize.toUInt64_toNat
code: @[simp] theorem USize.toUInt64_toNat (x : USize) : x.toUInt64.toNat = x.toNat 
goal: x.toUInt64.toNat = x.toNat

full_name: UInt32.toUSize_toNat
code: @[simp] theorem UInt32.toUSize_toNat (x : UInt32) : x.toUSize.toNat = x.toNat 
goal: x.toUSize.toNat = x.toNat

full_name: USize.toNat_zero
code: theorem USize.toNat_zero : (0 : USize).toNat = 0 
goal: USize.toNat 0 = 0

full_name: USize.toNat_add
code: theorem USize.toNat_add (x y : USize) : (x + y).toNat = (x.toNat + y.toNat) % USize.size 
goal: (x + y).toNat = (x.toNat + y.toNat) % USize.size

full_name: USize.toNat_sub
code: theorem USize.toNat_sub (x y : USize) :
    (x - y).toNat = (USize.size - y.toNat + x.toNat) % USize.size 
goal: (x - y).toNat = (USize.size - y.toNat + x.toNat) % USize.size

full_name: USize.toNat_mul
code: theorem USize.toNat_mul (x y : USize) : (x * y).toNat = (x.toNat * y.toNat) % USize.size 
goal: (x * y).toNat = x.toNat * y.toNat % USize.size

full_name: USize.toNat_div
code: theorem USize.toNat_div (x y : USize) : (x / y).toNat = x.toNat / y.toNat 
goal: (x / y).toNat = x.toNat / y.toNat

full_name: USize.toNat_mod
code: theorem USize.toNat_mod (x y : USize) : (x % y).toNat = x.toNat % y.toNat 
goal: (x % y).toNat = x.toNat % y.toNat

full_name: USize.toNat_modn
code: theorem USize.toNat_modn (x : USize) (n) : (x.modn n).toNat = x.toNat % n 
goal: (x.modn n).toNat = x.toNat % n

full_name: USize.le_antisymm_iff
code: theorem USize.le_antisymm_iff {x y : USize} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: USize.le_antisymm
code: theorem USize.le_antisymm {x y : USize} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdUSize_.lake»
code: instance : Batteries.LawfulOrd USize 
goal: Batteries.LawfulOrd USize