File: .lake/packages/lean4/src/lean/Init/Data/UInt/Lemmas.lean

full_name: «_aux_.lake_packages_lean4_src_lean_Init_Data_UInt_Lemmas___macroRules_commandDeclare_uint_theorems__1»
code: macro "declare_uint_theorems" typeName:ident : command =>
`(
namespace $typeName

instance : Inhabited $typeName where
  default := 0

theorem zero_def : (0 : $typeName) = ⟨0⟩ := rfl
theorem one_def : (1 : $typeName) = ⟨1⟩ := rfl
theorem sub_def (a b : $typeName) : a - b = ⟨a.val - b.val⟩ := rfl
theorem mul_def (a b : $typeName) : a * b = ⟨a.val * b.val⟩ := rfl
theorem mod_def (a b : $typeName) : a % b = ⟨a.val % b.val⟩ := rfl
theorem add_def (a b : $typeName) : a + b = ⟨a.val + b.val⟩ := rfl

@[simp] theorem mk_val_eq : ∀ (a : $typeName), mk a.val = a
  | ⟨_, _⟩ => rfl
theorem val_eq_of_lt {a : Nat} : a < size → ((ofNat a).val : Nat) = a :=
  Nat.mod_eq_of_lt

theorem le_def {a b : $typeName} : a ≤ b ↔ a.1 ≤ b.1 := .rfl
theorem lt_def {a b : $typeName} : a < b ↔ a.1 < b.1 := .rfl
theorem lt_iff_val_lt_val {a b : $typeName} : a < b ↔ a.val < b.val := .rfl
@[simp] protected theorem not_le {a b : $typeName} : ¬ a ≤ b ↔ b < a := Fin.not_le
@[simp] protected theorem not_lt {a b : $typeName} : ¬ a < b ↔ b ≤ a := Fin.not_lt
@[simp] protected theorem le_refl (a : $typeName) : a ≤ a := by simp [le_def]
@[simp] protected theorem lt_irrefl (a : $typeName) : ¬ a < a := by simp
protected theorem le_trans {a b c : $typeName} : a ≤ b → b ≤ c → a ≤ c := Fin.le_trans
protected theorem lt_trans {a b c : $typeName} : a < b → b < c → a < c := Fin.lt_trans
protected theorem le_total (a b : $typeName) : a ≤ b ∨ b ≤ a := Fin.le_total a.1 b.1
protected theorem lt_asymm {a b : $typeName} (h : a < b) : ¬ b < a := Fin.lt_asymm h
protected theorem val_eq_of_eq {a b : $typeName} (h : a = b) : a.val = b.val := h ▸ rfl
protected theorem eq_of_val_eq {a b : $typeName} (h : a.val = b.val) : a = b := by cases a; cases b; simp at h; simp [h]
open $typeName (val_eq_of_eq) in
protected theorem ne_of_val_ne {a b : $typeName} (h : a.val ≠ b.val) : a ≠ b := fun h' => absurd (val_eq_of_eq h') h
open $typeName (ne_of_val_ne) in
protected theorem ne_of_lt {a b : $typeName} (h : a < b) : a ≠ b := ne_of_val_ne (Fin.ne_of_lt h)

@[simp] protected theorem zero_toNat : (0 : $typeName).toNat = 0 := Nat.zero_mod _
@[simp] protected theorem mod_toNat (a b : $typeName) : (a % b).toNat = a.toNat % b.toNat := Fin.mod_val ..
@[simp] protected theorem div_toNat (a b : $typeName) : (a / b).toNat = a.toNat / b.toNat := Fin.div_val ..
@[simp] protected theorem modn_toNat (a : $typeName) (b : Nat) : (a.modn b).toNat = a.toNat % b := Fin.modn_val ..
protected theorem modn_lt {m : Nat} : ∀ (u : $typeName), m > 0 → toNat (u % m) < m
  | ⟨u⟩, h => Fin.modn_lt u h
open $typeName (modn_lt) in
protected theorem mod_lt (a b : $typeName) (h : 0 < b) : a % b < b := modn_lt _ (by simp [lt_def] at h; exact h)
protected theorem toNat.inj : ∀ {a b : $typeName}, a.toNat = b.toNat → a = b
  | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl

end $typeName
)
goal: Lean.Macro

full_name: commandDeclare_uint_theorems_
code: macro "declare_uint_theorems" typeName:ident : command =>
`(
namespace $typeName

instance : Inhabited $typeName where
  default := 0

theorem zero_def : (0 : $typeName) = ⟨0⟩ := rfl
theorem one_def : (1 : $typeName) = ⟨1⟩ := rfl
theorem sub_def (a b : $typeName) : a - b = ⟨a.val - b.val⟩ := rfl
theorem mul_def (a b : $typeName) : a * b = ⟨a.val * b.val⟩ := rfl
theorem mod_def (a b : $typeName) : a % b = ⟨a.val % b.val⟩ := rfl
theorem add_def (a b : $typeName) : a + b = ⟨a.val + b.val⟩ := rfl

@[simp] theorem mk_val_eq : ∀ (a : $typeName), mk a.val = a
  | ⟨_, _⟩ => rfl
theorem val_eq_of_lt {a : Nat} : a < size → ((ofNat a).val : Nat) = a :=
  Nat.mod_eq_of_lt

theorem le_def {a b : $typeName} : a ≤ b ↔ a.1 ≤ b.1 := .rfl
theorem lt_def {a b : $typeName} : a < b ↔ a.1 < b.1 := .rfl
theorem lt_iff_val_lt_val {a b : $typeName} : a < b ↔ a.val < b.val := .rfl
@[simp] protected theorem not_le {a b : $typeName} : ¬ a ≤ b ↔ b < a := Fin.not_le
@[simp] protected theorem not_lt {a b : $typeName} : ¬ a < b ↔ b ≤ a := Fin.not_lt
@[simp] protected theorem le_refl (a : $typeName) : a ≤ a := by simp [le_def]
@[simp] protected theorem lt_irrefl (a : $typeName) : ¬ a < a := by simp
protected theorem le_trans {a b c : $typeName} : a ≤ b → b ≤ c → a ≤ c := Fin.le_trans
protected theorem lt_trans {a b c : $typeName} : a < b → b < c → a < c := Fin.lt_trans
protected theorem le_total (a b : $typeName) : a ≤ b ∨ b ≤ a := Fin.le_total a.1 b.1
protected theorem lt_asymm {a b : $typeName} (h : a < b) : ¬ b < a := Fin.lt_asymm h
protected theorem val_eq_of_eq {a b : $typeName} (h : a = b) : a.val = b.val := h ▸ rfl
protected theorem eq_of_val_eq {a b : $typeName} (h : a.val = b.val) : a = b := by cases a; cases b; simp at h; simp [h]
open $typeName (val_eq_of_eq) in
protected theorem ne_of_val_ne {a b : $typeName} (h : a.val ≠ b.val) : a ≠ b := fun h' => absurd (val_eq_of_eq h') h
open $typeName (ne_of_val_ne) in
protected theorem ne_of_lt {a b : $typeName} (h : a < b) : a ≠ b := ne_of_val_ne (Fin.ne_of_lt h)

@[simp] protected theorem zero_toNat : (0 : $typeName).toNat = 0 := Nat.zero_mod _
@[simp] protected theorem mod_toNat (a b : $typeName) : (a % b).toNat = a.toNat % b.toNat := Fin.mod_val ..
@[simp] protected theorem div_toNat (a b : $typeName) : (a / b).toNat = a.toNat / b.toNat := Fin.div_val ..
@[simp] protected theorem modn_toNat (a : $typeName) (b : Nat) : (a.modn b).toNat = a.toNat % b := Fin.modn_val ..
protected theorem modn_lt {m : Nat} : ∀ (u : $typeName), m > 0 → toNat (u % m) < m
  | ⟨u⟩, h => Fin.modn_lt u h
open $typeName (modn_lt) in
protected theorem mod_lt (a b : $typeName) (h : 0 < b) : a % b < b := modn_lt _ (by simp [lt_def] at h; exact h)
protected theorem toNat.inj : ∀ {a b : $typeName}, a.toNat = b.toNat → a = b
  | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl

end $typeName
)
goal: Lean.ParserDescr

full_name: UInt8.mod_def
code: declare_uint_theorems UInt8
goal: a % b = { val := a.val % b.val }

full_name: UInt8.not_le
code: declare_uint_theorems UInt8
goal: ¬a ≤ b ↔ b < a

full_name: UInt8.lt_trans
code: declare_uint_theorems UInt8
goal: a < b → b < c → a < c

full_name: UInt8.one_def
code: declare_uint_theorems UInt8
goal: 1 = { val := 1 }

full_name: UInt8.modn_lt
code: declare_uint_theorems UInt8
goal: m > 0 → (u % m).toNat < m

full_name: UInt8.mul_def
code: declare_uint_theorems UInt8
goal: a * b = { val := a.val * b.val }

full_name: UInt8.sub_def
code: declare_uint_theorems UInt8
goal: a - b = { val := a.val - b.val }

full_name: UInt8.val_eq_of_lt
code: declare_uint_theorems UInt8
goal: a < UInt8.size → ↑(UInt8.ofNat a).val = a

full_name: UInt8.zero_toNat
code: declare_uint_theorems UInt8
goal: UInt8.toNat 0 = 0

full_name: UInt8.modn_toNat
code: declare_uint_theorems UInt8
goal: (a.modn b).toNat = a.toNat % b

full_name: UInt8.le_trans
code: declare_uint_theorems UInt8
goal: a ≤ b → b ≤ c → a ≤ c

full_name: UInt8.lt_asymm
code: declare_uint_theorems UInt8
goal: ¬b < a

full_name: UInt8.lt_irrefl
code: declare_uint_theorems UInt8
goal: ¬a < a

full_name: UInt8.le_refl
code: declare_uint_theorems UInt8
goal: a ≤ a

full_name: UInt8.not_lt
code: declare_uint_theorems UInt8
goal: ¬a < b ↔ b ≤ a

full_name: UInt8.ne_of_lt
code: declare_uint_theorems UInt8
goal: a ≠ b

full_name: UInt8.val_eq_of_eq
code: declare_uint_theorems UInt8
goal: a.val = b.val

full_name: UInt8.eq_of_val_eq
code: declare_uint_theorems UInt8
goal: a = b

full_name: UInt8.add_def
code: declare_uint_theorems UInt8
goal: a + b = { val := a.val + b.val }

full_name: UInt8.«instInhabited_.lake»
code: declare_uint_theorems UInt8
goal: Inhabited UInt8

full_name: UInt8.mk_val_eq
code: declare_uint_theorems UInt8
goal: { val := a.val } = a

full_name: UInt8.lt_def
code: declare_uint_theorems UInt8
goal: a < b ↔ a.val < b.val

full_name: UInt8.div_toNat
code: declare_uint_theorems UInt8
goal: (a / b).toNat = a.toNat / b.toNat

full_name: UInt8.ne_of_val_ne
code: declare_uint_theorems UInt8
goal: a ≠ b

full_name: UInt8.lt_iff_val_lt_val
code: declare_uint_theorems UInt8
goal: a < b ↔ a.val < b.val

full_name: UInt8.mod_lt
code: declare_uint_theorems UInt8
goal: a % b < b

full_name: UInt8.mod_toNat
code: declare_uint_theorems UInt8
goal: (a % b).toNat = a.toNat % b.toNat

full_name: UInt8.le_def
code: declare_uint_theorems UInt8
goal: a ≤ b ↔ a.val ≤ b.val

full_name: UInt8.toNat.inj
code: declare_uint_theorems UInt8
goal: a.toNat = b.toNat → a = b

full_name: UInt8.le_total
code: declare_uint_theorems UInt8
goal: a ≤ b ∨ b ≤ a

full_name: UInt8.zero_def
code: declare_uint_theorems UInt8
goal: 0 = { val := 0 }

full_name: UInt16.sub_def
code: declare_uint_theorems UInt16
goal: a - b = { val := a.val - b.val }

full_name: UInt16.le_trans
code: declare_uint_theorems UInt16
goal: a ≤ b → b ≤ c → a ≤ c

full_name: UInt16.mk_val_eq
code: declare_uint_theorems UInt16
goal: { val := a.val } = a

full_name: UInt16.mod_toNat
code: declare_uint_theorems UInt16
goal: (a % b).toNat = a.toNat % b.toNat

full_name: UInt16.mod_def
code: declare_uint_theorems UInt16
goal: a % b = { val := a.val % b.val }

full_name: UInt16.modn_toNat
code: declare_uint_theorems UInt16
goal: (a.modn b).toNat = a.toNat % b

full_name: UInt16.lt_trans
code: declare_uint_theorems UInt16
goal: a < b → b < c → a < c

full_name: UInt16.le_refl
code: declare_uint_theorems UInt16
goal: a ≤ a

full_name: UInt16.mul_def
code: declare_uint_theorems UInt16
goal: a * b = { val := a.val * b.val }

full_name: UInt16.«instInhabited_.lake»
code: declare_uint_theorems UInt16
goal: Inhabited UInt16

full_name: UInt16.not_lt
code: declare_uint_theorems UInt16
goal: ¬a < b ↔ b ≤ a

full_name: UInt16.le_def
code: declare_uint_theorems UInt16
goal: a ≤ b ↔ a.val ≤ b.val

full_name: UInt16.not_le
code: declare_uint_theorems UInt16
goal: ¬a ≤ b ↔ b < a

full_name: UInt16.zero_toNat
code: declare_uint_theorems UInt16
goal: UInt16.toNat 0 = 0

full_name: UInt16.lt_def
code: declare_uint_theorems UInt16
goal: a < b ↔ a.val < b.val

full_name: UInt16.toNat.inj
code: declare_uint_theorems UInt16
goal: a.toNat = b.toNat → a = b

full_name: UInt16.div_toNat
code: declare_uint_theorems UInt16
goal: (a / b).toNat = a.toNat / b.toNat

full_name: UInt16.val_eq_of_lt
code: declare_uint_theorems UInt16
goal: a < UInt16.size → ↑(UInt16.ofNat a).val = a

full_name: UInt16.lt_iff_val_lt_val
code: declare_uint_theorems UInt16
goal: a < b ↔ a.val < b.val

full_name: UInt16.mod_lt
code: declare_uint_theorems UInt16
goal: a % b < b

full_name: UInt16.one_def
code: declare_uint_theorems UInt16
goal: 1 = { val := 1 }

full_name: UInt16.le_total
code: declare_uint_theorems UInt16
goal: a ≤ b ∨ b ≤ a

full_name: UInt16.ne_of_lt
code: declare_uint_theorems UInt16
goal: a ≠ b

full_name: UInt16.lt_asymm
code: declare_uint_theorems UInt16
goal: ¬b < a

full_name: UInt16.add_def
code: declare_uint_theorems UInt16
goal: a + b = { val := a.val + b.val }

full_name: UInt16.modn_lt
code: declare_uint_theorems UInt16
goal: m > 0 → (u % m).toNat < m

full_name: UInt16.ne_of_val_ne
code: declare_uint_theorems UInt16
goal: a ≠ b

full_name: UInt16.eq_of_val_eq
code: declare_uint_theorems UInt16
goal: a = b

full_name: UInt16.lt_irrefl
code: declare_uint_theorems UInt16
goal: ¬a < a

full_name: UInt16.val_eq_of_eq
code: declare_uint_theorems UInt16
goal: a.val = b.val

full_name: UInt16.zero_def
code: declare_uint_theorems UInt16
goal: 0 = { val := 0 }

full_name: UInt32.mk_val_eq
code: declare_uint_theorems UInt32
goal: { val := a.val } = a

full_name: UInt32.ne_of_lt
code: declare_uint_theorems UInt32
goal: a ≠ b

full_name: UInt32.add_def
code: declare_uint_theorems UInt32
goal: a + b = { val := a.val + b.val }

full_name: UInt32.lt_asymm
code: declare_uint_theorems UInt32
goal: ¬b < a

full_name: UInt32.lt_def
code: declare_uint_theorems UInt32
goal: a < b ↔ a.val < b.val

full_name: UInt32.modn_toNat
code: declare_uint_theorems UInt32
goal: (a.modn b).toNat = a.toNat % b

full_name: UInt32.zero_toNat
code: declare_uint_theorems UInt32
goal: UInt32.toNat 0 = 0

full_name: UInt32.le_trans
code: declare_uint_theorems UInt32
goal: a ≤ b → b ≤ c → a ≤ c

full_name: UInt32.not_le
code: declare_uint_theorems UInt32
goal: ¬a ≤ b ↔ b < a

full_name: UInt32.le_refl
code: declare_uint_theorems UInt32
goal: a ≤ a

full_name: UInt32.lt_trans
code: declare_uint_theorems UInt32
goal: a < b → b < c → a < c

full_name: UInt32.mod_toNat
code: declare_uint_theorems UInt32
goal: (a % b).toNat = a.toNat % b.toNat

full_name: UInt32.modn_lt
code: declare_uint_theorems UInt32
goal: m > 0 → (u % m).toNat < m

full_name: UInt32.div_toNat
code: declare_uint_theorems UInt32
goal: (a / b).toNat = a.toNat / b.toNat

full_name: UInt32.zero_def
code: declare_uint_theorems UInt32
goal: 0 = { val := 0 }

full_name: UInt32.lt_iff_val_lt_val
code: declare_uint_theorems UInt32
goal: a < b ↔ a.val < b.val

full_name: UInt32.lt_irrefl
code: declare_uint_theorems UInt32
goal: ¬a < a

full_name: UInt32.one_def
code: declare_uint_theorems UInt32
goal: 1 = { val := 1 }

full_name: UInt32.mod_lt
code: declare_uint_theorems UInt32
goal: a % b < b

full_name: UInt32.toNat.inj
code: declare_uint_theorems UInt32
goal: a.toNat = b.toNat → a = b

full_name: UInt32.val_eq_of_lt
code: declare_uint_theorems UInt32
goal: a < UInt32.size → ↑(UInt32.ofNat a).val = a

full_name: UInt32.ne_of_val_ne
code: declare_uint_theorems UInt32
goal: a ≠ b

full_name: UInt32.le_def
code: declare_uint_theorems UInt32
goal: a ≤ b ↔ a.val ≤ b.val

full_name: UInt32.eq_of_val_eq
code: declare_uint_theorems UInt32
goal: a = b

full_name: UInt32.mod_def
code: declare_uint_theorems UInt32
goal: a % b = { val := a.val % b.val }

full_name: UInt32.sub_def
code: declare_uint_theorems UInt32
goal: a - b = { val := a.val - b.val }

full_name: UInt32.mul_def
code: declare_uint_theorems UInt32
goal: a * b = { val := a.val * b.val }

full_name: UInt32.val_eq_of_eq
code: declare_uint_theorems UInt32
goal: a.val = b.val

full_name: UInt32.«instInhabited_.lake»
code: declare_uint_theorems UInt32
goal: Inhabited UInt32

full_name: UInt32.not_lt
code: declare_uint_theorems UInt32
goal: ¬a < b ↔ b ≤ a

full_name: UInt32.le_total
code: declare_uint_theorems UInt32
goal: a ≤ b ∨ b ≤ a

full_name: UInt64.toNat.inj
code: declare_uint_theorems UInt64
goal: a.toNat = b.toNat → a = b

full_name: UInt64.sub_def
code: declare_uint_theorems UInt64
goal: a - b = { val := a.val - b.val }

full_name: UInt64.ne_of_lt
code: declare_uint_theorems UInt64
goal: a ≠ b

full_name: UInt64.eq_of_val_eq
code: declare_uint_theorems UInt64
goal: a = b

full_name: UInt64.mod_toNat
code: declare_uint_theorems UInt64
goal: (a % b).toNat = a.toNat % b.toNat

full_name: UInt64.le_total
code: declare_uint_theorems UInt64
goal: a ≤ b ∨ b ≤ a

full_name: UInt64.mk_val_eq
code: declare_uint_theorems UInt64
goal: { val := a.val } = a

full_name: UInt64.lt_trans
code: declare_uint_theorems UInt64
goal: a < b → b < c → a < c

full_name: UInt64.le_def
code: declare_uint_theorems UInt64
goal: a ≤ b ↔ a.val ≤ b.val

full_name: UInt64.zero_def
code: declare_uint_theorems UInt64
goal: 0 = { val := 0 }

full_name: UInt64.val_eq_of_eq
code: declare_uint_theorems UInt64
goal: a.val = b.val

full_name: UInt64.«instInhabited_.lake»
code: declare_uint_theorems UInt64
goal: Inhabited UInt64

full_name: UInt64.add_def
code: declare_uint_theorems UInt64
goal: a + b = { val := a.val + b.val }

full_name: UInt64.one_def
code: declare_uint_theorems UInt64
goal: 1 = { val := 1 }

full_name: UInt64.val_eq_of_lt
code: declare_uint_theorems UInt64
goal: a < UInt64.size → ↑(UInt64.ofNat a).val = a

full_name: UInt64.modn_lt
code: declare_uint_theorems UInt64
goal: m > 0 → (u % m).toNat < m

full_name: UInt64.div_toNat
code: declare_uint_theorems UInt64
goal: (a / b).toNat = a.toNat / b.toNat

full_name: UInt64.not_le
code: declare_uint_theorems UInt64
goal: ¬a ≤ b ↔ b < a

full_name: UInt64.not_lt
code: declare_uint_theorems UInt64
goal: ¬a < b ↔ b ≤ a

full_name: UInt64.lt_def
code: declare_uint_theorems UInt64
goal: a < b ↔ a.val < b.val

full_name: UInt64.lt_iff_val_lt_val
code: declare_uint_theorems UInt64
goal: a < b ↔ a.val < b.val

full_name: UInt64.lt_irrefl
code: declare_uint_theorems UInt64
goal: ¬a < a

full_name: UInt64.lt_asymm
code: declare_uint_theorems UInt64
goal: ¬b < a

full_name: UInt64.mul_def
code: declare_uint_theorems UInt64
goal: a * b = { val := a.val * b.val }

full_name: UInt64.modn_toNat
code: declare_uint_theorems UInt64
goal: (a.modn b).toNat = a.toNat % b

full_name: UInt64.mod_lt
code: declare_uint_theorems UInt64
goal: a % b < b

full_name: UInt64.le_refl
code: declare_uint_theorems UInt64
goal: a ≤ a

full_name: UInt64.mod_def
code: declare_uint_theorems UInt64
goal: a % b = { val := a.val % b.val }

full_name: UInt64.ne_of_val_ne
code: declare_uint_theorems UInt64
goal: a ≠ b

full_name: UInt64.le_trans
code: declare_uint_theorems UInt64
goal: a ≤ b → b ≤ c → a ≤ c

full_name: UInt64.zero_toNat
code: declare_uint_theorems UInt64
goal: UInt64.toNat 0 = 0

full_name: USize.one_def
code: declare_uint_theorems USize
goal: 1 = { val := 1 }

full_name: USize.le_def
code: declare_uint_theorems USize
goal: a ≤ b ↔ a.val ≤ b.val

full_name: USize.modn_lt
code: declare_uint_theorems USize
goal: m > 0 → (u % m).toNat < m

full_name: USize.mul_def
code: declare_uint_theorems USize
goal: a * b = { val := a.val * b.val }

full_name: USize.lt_trans
code: declare_uint_theorems USize
goal: a < b → b < c → a < c

full_name: USize.eq_of_val_eq
code: declare_uint_theorems USize
goal: a = b

full_name: USize.zero_def
code: declare_uint_theorems USize
goal: 0 = { val := 0 }

full_name: USize.lt_asymm
code: declare_uint_theorems USize
goal: ¬b < a

full_name: USize.mk_val_eq
code: declare_uint_theorems USize
goal: { val := a.val } = a

full_name: USize.lt_iff_val_lt_val
code: declare_uint_theorems USize
goal: a < b ↔ a.val < b.val

full_name: USize.mod_toNat
code: declare_uint_theorems USize
goal: (a % b).toNat = a.toNat % b.toNat

full_name: USize.mod_lt
code: declare_uint_theorems USize
goal: a % b < b

full_name: USize.lt_irrefl
code: declare_uint_theorems USize
goal: ¬a < a

full_name: USize.val_eq_of_eq
code: declare_uint_theorems USize
goal: a.val = b.val

full_name: USize.le_trans
code: declare_uint_theorems USize
goal: a ≤ b → b ≤ c → a ≤ c

full_name: USize.toNat.inj
code: declare_uint_theorems USize
goal: a.toNat = b.toNat → a = b

full_name: USize.lt_def
code: declare_uint_theorems USize
goal: a < b ↔ a.val < b.val

full_name: USize.le_total
code: declare_uint_theorems USize
goal: a ≤ b ∨ b ≤ a

full_name: USize.not_le
code: declare_uint_theorems USize
goal: ¬a ≤ b ↔ b < a

full_name: USize.div_toNat
code: declare_uint_theorems USize
goal: (a / b).toNat = a.toNat / b.toNat

full_name: USize.le_refl
code: declare_uint_theorems USize
goal: a ≤ a

full_name: USize.val_eq_of_lt
code: declare_uint_theorems USize
goal: a < USize.size → ↑(USize.ofNat a).val = a

full_name: USize.add_def
code: declare_uint_theorems USize
goal: a + b = { val := a.val + b.val }

full_name: USize.modn_toNat
code: declare_uint_theorems USize
goal: (a.modn b).toNat = a.toNat % b

full_name: USize.zero_toNat
code: declare_uint_theorems USize
goal: USize.toNat 0 = 0

full_name: USize.mod_def
code: declare_uint_theorems USize
goal: a % b = { val := a.val % b.val }

full_name: USize.«instInhabited_.lake»
code: declare_uint_theorems USize
goal: Inhabited USize

full_name: USize.not_lt
code: declare_uint_theorems USize
goal: ¬a < b ↔ b ≤ a

full_name: USize.ne_of_lt
code: declare_uint_theorems USize
goal: a ≠ b

full_name: USize.ne_of_val_ne
code: declare_uint_theorems USize
goal: a ≠ b

full_name: USize.sub_def
code: declare_uint_theorems USize
goal: a - b = { val := a.val - b.val }