ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Sum.getLeft_eq_iff
@[simp] theorem getLeft_eq_iff (h : x.isLeft) : x.getLeft h = a ↔ x = inl a 
Goal: ∀ {α : Type u_1} {a : α} {β : Type u_2} {x : α ⊕ β} (h : x.isLeft = true), x.getLeft h = a ↔ x = Sum.inl a
-- Sum.eq_right_getRight_of_isRight
theorem eq_right_getRight_of_isRight : ∀ {x : α ⊕ β} (h : x.isRight), x = inr (x.getRight h)
  
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β} (h : x.isRight = true)
Goal: x = Sum.inr (x.getRight h)
-- Sum.getRight_eq_iff
@[simp] theorem getRight_eq_iff (h : x.isRight) : x.getRight h = b ↔ x = inr b 
Goal: ∀ {β : Type u_1} {b : β} {α : Type u_2} {x : α ⊕ β} (h : x.isRight = true), x.getRight h = b ↔ x = Sum.inr b
-- Sum.getLeft?_eq_some_iff
@[simp] theorem getLeft?_eq_some_iff : x.getLeft? = some a ↔ x = inl a 
Goal: ∀ {α : Type u_1} {a : α} {β : Type u_2} {x : α ⊕ β}, x.getLeft? = some a ↔ x = Sum.inl a
-- Sum.getRight?_eq_some_iff
@[simp] theorem getRight?_eq_some_iff : x.getRight? = some b ↔ x = inr b 
Goal: ∀ {β : Type u_1} {b : β} {α : Type u_2} {x : α ⊕ β}, x.getRight? = some b ↔ x = Sum.inr b
-- Sum.bnot_isLeft
@[simp] theorem bnot_isLeft (x : α ⊕ β) : !x.isLeft = x.isRight 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: (!decide (x.isLeft = x.isRight)) = true
-- Sum.isLeft_eq_false
@[simp] theorem isLeft_eq_false {x : α ⊕ β} : x.isLeft = false ↔ x.isRight 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: x.isLeft = false ↔ x.isRight = true
-- Sum.not_isLeft
theorem not_isLeft {x : α ⊕ β} : ¬x.isLeft ↔ x.isRight 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: ¬x.isLeft = true ↔ x.isRight = true
-- Sum.bnot_isRight
@[simp] theorem bnot_isRight (x : α ⊕ β) : !x.isRight = x.isLeft 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: (!decide (x.isRight = x.isLeft)) = true
-- Sum.isRight_eq_false
@[simp] theorem isRight_eq_false {x : α ⊕ β} : x.isRight = false ↔ x.isLeft 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: x.isRight = false ↔ x.isLeft = true
-- Sum.not_isRight
theorem not_isRight {x : α ⊕ β} : ¬x.isRight ↔ x.isLeft 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: ¬x.isRight = true ↔ x.isLeft = true
-- Sum.isLeft_iff
theorem isLeft_iff : x.isLeft ↔ ∃ y, x = Sum.inl y 
Goal: ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, x.isLeft = true ↔ ∃ y, x = Sum.inl y
-- Sum.isRight_iff
theorem isRight_iff : x.isRight ↔ ∃ y, x = Sum.inr y 
Goal: ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, x.isRight = true ↔ ∃ y, x = Sum.inr y
-- Sum.inl.inj_iff
theorem inl.inj_iff : (inl a : α ⊕ β) = inl b ↔ a = b 
Arguments: {α : Type u_1} {β : Type u_2} {a b : α}
Goal: Sum.inl a = Sum.inl b ↔ a = b
-- Sum.inr.inj_iff
theorem inr.inj_iff : (inr a : α ⊕ β) = inr b ↔ a = b 
Arguments: {α : Type u_1} {β : Type u_2} {a b : β}
Goal: Sum.inr a = Sum.inr b ↔ a = b
-- Sum.inl_ne_inr
theorem inl_ne_inr : inl a ≠ inr b 
Goal: ∀ {α : Type u_1} {a : α} {β : Type u_2} {b : β}, Sum.inl a ≠ Sum.inr b
-- Sum.inr_ne_inl
theorem inr_ne_inl : inr b ≠ inl a 
Goal: ∀ {β : Type u_1} {b : β} {α : Type u_2} {a : α}, Sum.inr b ≠ Sum.inl a
-- Sum.elim_comp_inl
@[simp] theorem elim_comp_inl (f : α → γ) (g : β → γ) : Sum.elim f g ∘ inl = f 
Arguments: {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ)
Goal: Sum.elim f g ∘ Sum.inl = f
-- Sum.elim_comp_inr
@[simp] theorem elim_comp_inr (f : α → γ) (g : β → γ) : Sum.elim f g ∘ inr = g 
Arguments: {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ)
Goal: Sum.elim f g ∘ Sum.inr = g
-- Sum.elim_inl_inr
@[simp] theorem elim_inl_inr : @Sum.elim α β _ inl inr = id 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Sum.elim Sum.inl Sum.inr = id
-- Sum.comp_elim
theorem comp_elim (f : γ → δ) (g : α → γ) (h : β → γ) :
    f ∘ Sum.elim g h = Sum.elim (f ∘ g) (f ∘ h) 
Arguments: {γ : Sort u_1} {δ : Sort u_2} {α : Type u_3} {β : Type u_4} (f : γ → δ) (g : α → γ) (h : β → γ)
Goal: f ∘ Sum.elim g h = Sum.elim (f ∘ g) (f ∘ h)
-- Sum.elim_comp_inl_inr
@[simp] theorem elim_comp_inl_inr (f : α ⊕ β → γ) :
    Sum.elim (f ∘ inl) (f ∘ inr) = f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Sort u_3} (f : α ⊕ β → γ)
Goal: Sum.elim (f ∘ Sum.inl) (f ∘ Sum.inr) = f
-- Sum.elim_eq_iff
theorem elim_eq_iff {u u' : α → γ} {v v' : β → γ} :
    Sum.elim u v = Sum.elim u' v' ↔ u = u' ∧ v = v' 
Arguments: {α : Type u_1} {γ : Sort u_2} {β : Type u_3} {u u' : α → γ} {v v' : β → γ}
Goal: Sum.elim u v = Sum.elim u' v' ↔ u = u' ∧ v = v'
-- Sum.map_map
@[simp] theorem map_map (f' : α' → α'') (g' : β' → β'') (f : α → α') (g : β → β') :
    ∀ x : Sum α β, (x.map f g).map f' g' = x.map (f' ∘ f) (g' ∘ g)
  
Arguments: {α' : Type u_1} {α'' : Type u_2} {β' : Type u_3} {β'' : Type u_4} {α : Type u_5} {β : Type u_6} (f' : α' → α'') (g' : β' → β'') (f : α → α') (g : β → β') (x : α ⊕ β)
Goal: Sum.map f' g' (Sum.map f g x) = Sum.map (f' ∘ f) (g' ∘ g) x
-- Sum.map_comp_map
@[simp] theorem map_comp_map (f' : α' → α'') (g' : β' → β'') (f : α → α') (g : β → β') :
    Sum.map f' g' ∘ Sum.map f g = Sum.map (f' ∘ f) (g' ∘ g) 
Arguments: {α' : Type u_1} {α'' : Type u_2} {β' : Type u_3} {β'' : Type u_4} {α : Type u_5} {β : Type u_6} (f' : α' → α'') (g' : β' → β'') (f : α → α') (g : β → β')
Goal: Sum.map f' g' ∘ Sum.map f g = Sum.map (f' ∘ f) (g' ∘ g)
-- Sum.map_id_id
@[simp] theorem map_id_id : Sum.map (@id α) (@id β) = id 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Sum.map id id = id
-- Sum.elim_map
theorem elim_map {f₁ : α → β} {f₂ : β → ε} {g₁ : γ → δ} {g₂ : δ → ε} {x} :
    Sum.elim f₂ g₂ (Sum.map f₁ g₁ x) = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) x 
Arguments: {α : Type u_1} {β : Type u_2} {ε : Sort u_3} {γ : Type u_4} {δ : Type u_5} {f₁ : α → β} {f₂ : β → ε} {g₁ : γ → δ} {g₂ : δ → ε} {x : α ⊕ γ}
Goal: Sum.elim f₂ g₂ (Sum.map f₁ g₁ x) = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) x
-- Sum.elim_comp_map
theorem elim_comp_map {f₁ : α → β} {f₂ : β → ε} {g₁ : γ → δ} {g₂ : δ → ε} :
    Sum.elim f₂ g₂ ∘ Sum.map f₁ g₁ = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) 
Arguments: {α : Type u_1} {β : Type u_2} {ε : Sort u_3} {γ : Type u_4} {δ : Type u_5} {f₁ : α → β} {f₂ : β → ε} {g₁ : γ → δ} {g₂ : δ → ε}
Goal: Sum.elim f₂ g₂ ∘ Sum.map f₁ g₁ = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁)
-- Sum.isLeft_map
@[simp] theorem isLeft_map (f : α → β) (g : γ → δ) (x : α ⊕ γ) :
    isLeft (x.map f g) = isLeft x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α ⊕ γ)
Goal: (Sum.map f g x).isLeft = x.isLeft
-- Sum.isRight_map
@[simp] theorem isRight_map (f : α → β) (g : γ → δ) (x : α ⊕ γ) :
    isRight (x.map f g) = isRight x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α ⊕ γ)
Goal: (Sum.map f g x).isRight = x.isRight
-- Sum.getLeft?_map
@[simp] theorem getLeft?_map (f : α → β) (g : γ → δ) (x : α ⊕ γ) :
    (x.map f g).getLeft? = x.getLeft?.map f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α ⊕ γ)
Goal: (Sum.map f g x).getLeft? = Option.map f x.getLeft?
-- Sum.getRight?_map
@[simp] theorem getRight?_map (f : α → β) (g : γ → δ) (x : α ⊕ γ) :
    (x.map f g).getRight? = x.getRight?.map g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α ⊕ γ)
Goal: (Sum.map f g x).getRight? = Option.map g x.getRight?
-- Sum.swap_swap
@[simp] theorem swap_swap (x : α ⊕ β) : swap (swap x) = x 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: x.swap.swap = x
-- Sum.swap_swap_eq
@[simp] theorem swap_swap_eq : swap ∘ swap = @id (α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Sum.swap ∘ Sum.swap = id
-- Sum.isLeft_swap
@[simp] theorem isLeft_swap (x : α ⊕ β) : x.swap.isLeft = x.isRight 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: x.swap.isLeft = x.isRight
-- Sum.isRight_swap
@[simp] theorem isRight_swap (x : α ⊕ β) : x.swap.isRight = x.isLeft 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: x.swap.isRight = x.isLeft
-- Sum.getLeft?_swap
@[simp] theorem getLeft?_swap (x : α ⊕ β) : x.swap.getLeft? = x.getRight? 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: x.swap.getLeft? = x.getRight?
-- Sum.getRight?_swap
@[simp] theorem getRight?_swap (x : α ⊕ β) : x.swap.getRight? = x.getLeft? 
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β)
Goal: x.swap.getRight? = x.getLeft?
-- Sum.LiftRel.mono
theorem LiftRel.mono (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ a b, s₁ a b → s₂ a b)
  (h : LiftRel r₁ s₁ x y) : LiftRel r₂ s₂ x y 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {r₁ r₂ : α → α_1 → Prop} {β : Type u_3} {β_1 : Type u_4} {s₁ s₂ : β → β_1 → Prop}
  {x : α ⊕ β} {y : α_1 ⊕ β_1},
  (∀ (a : α) (b : α_1), r₁ a b → r₂ a b) →
    (∀ (a : β) (b : β_1), s₁ a b → s₂ a b) → Sum.LiftRel r₁ s₁ x y → Sum.LiftRel r₂ s₂ x y
-- Sum.LiftRel.mono_left
theorem LiftRel.mono_left (hr : ∀ a b, r₁ a b → r₂ a b) (h : LiftRel r₁ s x y) :
    LiftRel r₂ s x y 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {r₁ r₂ : α → α_1 → Prop} {β : Type u_3} {β_1 : Type u_4} {s : β → β_1 → Prop}
  {x : α ⊕ β} {y : α_1 ⊕ β_1}, (∀ (a : α) (b : α_1), r₁ a b → r₂ a b) → Sum.LiftRel r₁ s x y → Sum.LiftRel r₂ s x y
-- Sum.LiftRel.mono_right
theorem LiftRel.mono_right (hs : ∀ a b, s₁ a b → s₂ a b) (h : LiftRel r s₁ x y) :
    LiftRel r s₂ x y 
Goal: ∀ {β : Type u_1} {β_1 : Type u_2} {s₁ s₂ : β → β_1 → Prop} {α : Type u_3} {α_1 : Type u_4} {r : α → α_1 → Prop}
  {x : α ⊕ β} {y : α_1 ⊕ β_1}, (∀ (a : β) (b : β_1), s₁ a b → s₂ a b) → Sum.LiftRel r s₁ x y → Sum.LiftRel r s₂ x y
-- Sum.LiftRel.swap
protected theorem LiftRel.swap (h : LiftRel r s x y) : LiftRel s r x.swap y.swap 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {r : α → α_1 → Prop} {β : Type u_3} {β_1 : Type u_4} {s : β → β_1 → Prop} {x : α ⊕ β}
  {y : α_1 ⊕ β_1}, Sum.LiftRel r s x y → Sum.LiftRel s r x.swap y.swap
-- Sum.liftRel_swap_iff
@[simp] theorem liftRel_swap_iff : LiftRel s r x.swap y.swap ↔ LiftRel r s x y 
Goal: ∀ {β : Type u_1} {β_1 : Type u_2} {s : β → β_1 → Prop} {α : Type u_3} {α_1 : Type u_4} {r : α → α_1 → Prop} {x : α ⊕ β}
  {y : α_1 ⊕ β_1}, Sum.LiftRel s r x.swap y.swap ↔ Sum.LiftRel r s x y
-- Sum.LiftRel.lex
protected theorem LiftRel.lex {a b : α ⊕ β} (h : LiftRel r s a b) : Lex r s a b 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {a b : α ⊕ β} (h : Sum.LiftRel r s a b)
Goal: Sum.Lex r s a b
-- Sum.liftRel_subrelation_lex
theorem liftRel_subrelation_lex : Subrelation (LiftRel r s) (Lex r s) 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop}, Subrelation (Sum.LiftRel r s) (Sum.Lex r s)
-- Sum.Lex.mono
theorem Lex.mono (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ a b, s₁ a b → s₂ a b) (h : Lex r₁ s₁ x y) :
    Lex r₂ s₂ x y 
Goal: ∀ {α : Type u_1} {r₁ r₂ : α → α → Prop} {β : Type u_2} {s₁ s₂ : β → β → Prop} {x y : α ⊕ β},
  (∀ (a b : α), r₁ a b → r₂ a b) → (∀ (a b : β), s₁ a b → s₂ a b) → Sum.Lex r₁ s₁ x y → Sum.Lex r₂ s₂ x y
-- Sum.Lex.mono_left
theorem Lex.mono_left (hr : ∀ a b, r₁ a b → r₂ a b) (h : Lex r₁ s x y) : Lex r₂ s x y 
Goal: ∀ {α : Type u_1} {r₁ r₂ : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {x y : α ⊕ β},
  (∀ (a b : α), r₁ a b → r₂ a b) → Sum.Lex r₁ s x y → Sum.Lex r₂ s x y
-- Sum.Lex.mono_right
theorem Lex.mono_right (hs : ∀ a b, s₁ a b → s₂ a b) (h : Lex r s₁ x y) : Lex r s₂ x y 
Goal: ∀ {β : Type u_1} {s₁ s₂ : β → β → Prop} {α : Type u_2} {r : α → α → Prop} {x y : α ⊕ β},
  (∀ (a b : β), s₁ a b → s₂ a b) → Sum.Lex r s₁ x y → Sum.Lex r s₂ x y
-- Sum.lex_acc_inl
theorem lex_acc_inl (aca : Acc r a) : Acc (Lex r s) (inl a) 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {a : α} {β : Type u_2} {s : β → β → Prop}, Acc r a → Acc (Sum.Lex r s) (Sum.inl a)
-- Sum.lex_acc_inr
theorem lex_acc_inr (aca : ∀ a, Acc (Lex r s) (inl a)) {b} (acb : Acc s b) :
    Acc (Lex r s) (inr b) 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop},
  (∀ (a : α), Acc (Sum.Lex r s) (Sum.inl a)) → ∀ {b : β}, Acc s b → Acc (Sum.Lex r s) (Sum.inr b)
-- Sum.lex_wf
theorem lex_wf (ha : WellFounded r) (hb : WellFounded s) : WellFounded (Lex r s) 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {α_1 : Type u_2} {s : α_1 → α_1 → Prop},
  WellFounded r → WellFounded s → WellFounded (Sum.Lex r s)
-- Sum.elim_const_const
theorem elim_const_const (c : γ) :
    Sum.elim (const _ c : α → γ) (const _ c : β → γ) = const _ c 
Arguments: {γ : Sort u_1} {α : Type u_2} {β : Type u_3} (c : γ)
Goal: Sum.elim (Function.const α c) (Function.const β c) = Function.const (α ⊕ β) c
-- Sum.elim_lam_const_lam_const
@[simp] theorem elim_lam_const_lam_const (c : γ) :
    Sum.elim (fun _ : α => c) (fun _ : β => c) = fun _ => c 
Arguments: {γ : Sort u_1} {α : Type u_2} {β : Type u_3} (c : γ)
Goal: (Sum.elim (fun x => c) fun x => c) = fun x => c
-- Batteries.DList.invariant
structure DList (α : Type u) where
    apply     : List α → List α
    invariant : ∀ l, apply l = apply [] ++ l
Arguments: {α : Type u} (self : Batteries.DList α) (l : List α)
Goal: self.apply l = self.apply [] ++ l
-- UInt8.ext
@[ext] theorem UInt8.ext : {x y : UInt8} → x.toNat = y.toNat → x = y
  
Arguments: {x y : UInt8}
Goal: x.toNat = y.toNat → x = y
-- UInt8.ext_iff
theorem UInt8.ext_iff {x y : UInt8} : x = y ↔ x.toNat = y.toNat 
Arguments: {x y : UInt8}
Goal: x = y ↔ x.toNat = y.toNat
-- UInt8.val_val_eq_toNat
@[simp] theorem UInt8.val_val_eq_toNat (x : UInt8) : x.val.val = x.toNat 
Arguments: (x : UInt8)
Goal: ↑x.val = x.toNat
-- UInt8.val_ofNat
@[simp] theorem UInt8.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt8).val = OfNat.ofNat n 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).val = OfNat.ofNat n
-- UInt8.toNat_ofNat
@[simp] theorem UInt8.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt8).toNat = n % UInt8.size 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).toNat = n % UInt8.size
-- UInt8.toNat_lt
theorem UInt8.toNat_lt (x : UInt8) : x.toNat < 2 ^ 8 
Arguments: (x : UInt8)
Goal: x.toNat < 2 ^ 8
-- UInt8.toUInt16_toNat
@[simp] theorem UInt8.toUInt16_toNat (x : UInt8) : x.toUInt16.toNat = x.toNat 
Arguments: (x : UInt8)
Goal: x.toUInt16.toNat = x.toNat
-- UInt8.toUInt32_toNat
@[simp] theorem UInt8.toUInt32_toNat (x : UInt8) : x.toUInt32.toNat = x.toNat 
Arguments: (x : UInt8)
Goal: x.toUInt32.toNat = x.toNat
-- UInt8.toUInt64_toNat
@[simp] theorem UInt8.toUInt64_toNat (x : UInt8) : x.toUInt64.toNat = x.toNat 
Arguments: (x : UInt8)
Goal: x.toUInt64.toNat = x.toNat
-- UInt8.toNat_zero
theorem UInt8.toNat_zero : (0 : UInt8).toNat = 0 
Goal: UInt8.toNat 0 = 0
-- UInt8.toNat_add
theorem UInt8.toNat_add (x y : UInt8) : (x + y).toNat = (x.toNat + y.toNat) % UInt8.size 
Arguments: (x y : UInt8)
Goal: (x + y).toNat = (x.toNat + y.toNat) % UInt8.size
-- UInt8.toNat_sub
theorem UInt8.toNat_sub (x y : UInt8) :
    (x - y).toNat = (UInt8.size - y.toNat + x.toNat) % UInt8.size 
Arguments: (x y : UInt8)
Goal: (x - y).toNat = (UInt8.size - y.toNat + x.toNat) % UInt8.size
-- UInt8.toNat_mul
theorem UInt8.toNat_mul (x y : UInt8) : (x * y).toNat = (x.toNat * y.toNat) % UInt8.size 
Arguments: (x y : UInt8)
Goal: (x * y).toNat = x.toNat * y.toNat % UInt8.size
-- UInt8.toNat_div
theorem UInt8.toNat_div (x y : UInt8) : (x / y).toNat = x.toNat / y.toNat 
Arguments: (x y : UInt8)
Goal: (x / y).toNat = x.toNat / y.toNat
-- UInt8.toNat_mod
theorem UInt8.toNat_mod (x y : UInt8) : (x % y).toNat = x.toNat % y.toNat 
Arguments: (x y : UInt8)
Goal: (x % y).toNat = x.toNat % y.toNat
-- UInt8.toNat_modn
theorem UInt8.toNat_modn (x : UInt8) (n) : (x.modn n).toNat = x.toNat % n 
Arguments: (x : UInt8) (n : Nat)
Goal: (x.modn n).toNat = x.toNat % n
-- UInt8.le_antisymm_iff
theorem UInt8.le_antisymm_iff {x y : UInt8} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : UInt8}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- UInt8.le_antisymm
theorem UInt8.le_antisymm {x y : UInt8} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : UInt8} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- UInt16.ext
@[ext] theorem UInt16.ext : {x y : UInt16} → x.toNat = y.toNat → x = y
  
Arguments: {x y : UInt16}
Goal: x.toNat = y.toNat → x = y
-- UInt16.ext_iff
theorem UInt16.ext_iff {x y : UInt16} : x = y ↔ x.toNat = y.toNat 
Arguments: {x y : UInt16}
Goal: x = y ↔ x.toNat = y.toNat
-- UInt16.val_val_eq_toNat
@[simp] theorem UInt16.val_val_eq_toNat (x : UInt16) : x.val.val = x.toNat 
Arguments: (x : UInt16)
Goal: ↑x.val = x.toNat
-- UInt16.val_ofNat
@[simp] theorem UInt16.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt16).val = OfNat.ofNat n 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).val = OfNat.ofNat n
-- UInt16.toNat_ofNat
@[simp] theorem UInt16.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt16).toNat = n % UInt16.size 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).toNat = n % UInt16.size
-- UInt16.toNat_lt
theorem UInt16.toNat_lt (x : UInt16) : x.toNat < 2 ^ 16 
Arguments: (x : UInt16)
Goal: x.toNat < 2 ^ 16
-- UInt16.toUInt8_toNat
@[simp] theorem UInt16.toUInt8_toNat (x : UInt16) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
Arguments: (x : UInt16)
Goal: x.toUInt8.toNat = x.toNat % 2 ^ 8
-- UInt16.toUInt32_toNat
@[simp] theorem UInt16.toUInt32_toNat (x : UInt16) : x.toUInt32.toNat = x.toNat 
Arguments: (x : UInt16)
Goal: x.toUInt32.toNat = x.toNat
-- UInt16.toUInt64_toNat
@[simp] theorem UInt16.toUInt64_toNat (x : UInt16) : x.toUInt64.toNat = x.toNat 
Arguments: (x : UInt16)
Goal: x.toUInt64.toNat = x.toNat
-- UInt16.toNat_zero
theorem UInt16.toNat_zero : (0 : UInt16).toNat = 0 
Goal: UInt16.toNat 0 = 0
-- UInt16.toNat_add
theorem UInt16.toNat_add (x y : UInt16) : (x + y).toNat = (x.toNat + y.toNat) % UInt16.size 
Arguments: (x y : UInt16)
Goal: (x + y).toNat = (x.toNat + y.toNat) % UInt16.size
-- UInt16.toNat_sub
theorem UInt16.toNat_sub (x y : UInt16) :
    (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size 
Arguments: (x y : UInt16)
Goal: (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size
-- UInt16.toNat_mul
theorem UInt16.toNat_mul (x y : UInt16) : (x * y).toNat = (x.toNat * y.toNat) % UInt16.size 
Arguments: (x y : UInt16)
Goal: (x * y).toNat = x.toNat * y.toNat % UInt16.size
-- UInt16.toNat_div
theorem UInt16.toNat_div (x y : UInt16) : (x / y).toNat = x.toNat / y.toNat 
Arguments: (x y : UInt16)
Goal: (x / y).toNat = x.toNat / y.toNat
-- UInt16.toNat_mod
theorem UInt16.toNat_mod (x y : UInt16) : (x % y).toNat = x.toNat % y.toNat 
Arguments: (x y : UInt16)
Goal: (x % y).toNat = x.toNat % y.toNat
-- UInt16.toNat_modn
theorem UInt16.toNat_modn (x : UInt16) (n) : (x.modn n).toNat = x.toNat % n 
Arguments: (x : UInt16) (n : Nat)
Goal: (x.modn n).toNat = x.toNat % n
-- UInt16.le_antisymm_iff
theorem UInt16.le_antisymm_iff {x y : UInt16} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : UInt16}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- UInt16.le_antisymm
theorem UInt16.le_antisymm {x y : UInt16} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : UInt16} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- UInt32.ext
@[ext] theorem UInt32.ext : {x y : UInt32} → x.toNat = y.toNat → x = y
  
Arguments: {x y : UInt32}
Goal: x.toNat = y.toNat → x = y
-- UInt32.ext_iff
theorem UInt32.ext_iff {x y : UInt32} : x = y ↔ x.toNat = y.toNat 
Arguments: {x y : UInt32}
Goal: x = y ↔ x.toNat = y.toNat
-- UInt32.val_val_eq_toNat
@[simp] theorem UInt32.val_val_eq_toNat (x : UInt32) : x.val.val = x.toNat 
Arguments: (x : UInt32)
Goal: ↑x.val = x.toNat
-- UInt32.val_ofNat
@[simp] theorem UInt32.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).val = OfNat.ofNat n 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).val = OfNat.ofNat n
-- UInt32.toNat_ofNat
@[simp] theorem UInt32.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).toNat = n % UInt32.size 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).toNat = n % UInt32.size
-- UInt32.toNat_lt
theorem UInt32.toNat_lt (x : UInt32) : x.toNat < 2 ^ 32 
Arguments: (x : UInt32)
Goal: x.toNat < 2 ^ 32
-- UInt32.toUInt8_toNat
@[simp] theorem UInt32.toUInt8_toNat (x : UInt32) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
Arguments: (x : UInt32)
Goal: x.toUInt8.toNat = x.toNat % 2 ^ 8
-- UInt32.toUInt16_toNat
@[simp] theorem UInt32.toUInt16_toNat (x : UInt32) : x.toUInt16.toNat = x.toNat % 2 ^ 16 
Arguments: (x : UInt32)
Goal: x.toUInt16.toNat = x.toNat % 2 ^ 16
-- UInt32.toUInt64_toNat
@[simp] theorem UInt32.toUInt64_toNat (x : UInt32) : x.toUInt64.toNat = x.toNat 
Arguments: (x : UInt32)
Goal: x.toUInt64.toNat = x.toNat
-- UInt32.toNat_zero
theorem UInt32.toNat_zero : (0 : UInt32).toNat = 0 
Goal: UInt32.toNat 0 = 0
-- UInt32.toNat_add
theorem UInt32.toNat_add (x y : UInt32) : (x + y).toNat = (x.toNat + y.toNat) % UInt32.size 
Arguments: (x y : UInt32)
Goal: (x + y).toNat = (x.toNat + y.toNat) % UInt32.size
-- UInt32.toNat_sub
theorem UInt32.toNat_sub (x y : UInt32) :
    (x - y).toNat = (UInt32.size - y.toNat + x.toNat) % UInt32.size 
Arguments: (x y : UInt32)
Goal: (x - y).toNat = (UInt32.size - y.toNat + x.toNat) % UInt32.size
-- UInt32.toNat_mul
theorem UInt32.toNat_mul (x y : UInt32) : (x * y).toNat = (x.toNat * y.toNat) % UInt32.size 
Arguments: (x y : UInt32)
Goal: (x * y).toNat = x.toNat * y.toNat % UInt32.size
-- UInt32.toNat_div
theorem UInt32.toNat_div (x y : UInt32) : (x / y).toNat = x.toNat / y.toNat 
Arguments: (x y : UInt32)
Goal: (x / y).toNat = x.toNat / y.toNat
-- UInt32.toNat_mod
theorem UInt32.toNat_mod (x y : UInt32) : (x % y).toNat = x.toNat % y.toNat 
Arguments: (x y : UInt32)
Goal: (x % y).toNat = x.toNat % y.toNat
-- UInt32.toNat_modn
theorem UInt32.toNat_modn (x : UInt32) (n) : (x.modn n).toNat = x.toNat % n 
Arguments: (x : UInt32) (n : Nat)
Goal: (x.modn n).toNat = x.toNat % n
-- UInt32.le_antisymm_iff
theorem UInt32.le_antisymm_iff {x y : UInt32} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : UInt32}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- UInt32.le_antisymm
theorem UInt32.le_antisymm {x y : UInt32} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : UInt32} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- UInt64.ext
@[ext] theorem UInt64.ext : {x y : UInt64} → x.toNat = y.toNat → x = y
  
Arguments: {x y : UInt64}
Goal: x.toNat = y.toNat → x = y
-- UInt64.ext_iff
theorem UInt64.ext_iff {x y : UInt64} : x = y ↔ x.toNat = y.toNat 
Arguments: {x y : UInt64}
Goal: x = y ↔ x.toNat = y.toNat
-- UInt64.val_val_eq_toNat
@[simp] theorem UInt64.val_val_eq_toNat (x : UInt64) : x.val.val = x.toNat 
Arguments: (x : UInt64)
Goal: ↑x.val = x.toNat
-- UInt64.val_ofNat
@[simp] theorem UInt64.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt64).val = OfNat.ofNat n 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).val = OfNat.ofNat n
-- UInt64.toNat_ofNat
@[simp] theorem UInt64.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt64).toNat = n % UInt64.size 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).toNat = n % UInt64.size
-- UInt64.toNat_lt
theorem UInt64.toNat_lt (x : UInt64) : x.toNat < 2 ^ 64 
Arguments: (x : UInt64)
Goal: x.toNat < 2 ^ 64
-- UInt64.toUInt8_toNat
@[simp] theorem UInt64.toUInt8_toNat (x : UInt64) : x.toUInt8.toNat = x.toNat % 2 ^ 8 
Arguments: (x : UInt64)
Goal: x.toUInt8.toNat = x.toNat % 2 ^ 8
-- UInt64.toUInt16_toNat
@[simp] theorem UInt64.toUInt16_toNat (x : UInt64) : x.toUInt16.toNat = x.toNat % 2 ^ 16 
Arguments: (x : UInt64)
Goal: x.toUInt16.toNat = x.toNat % 2 ^ 16
-- UInt64.toUInt32_toNat
@[simp] theorem UInt64.toUInt32_toNat (x : UInt64) : x.toUInt32.toNat = x.toNat % 2 ^ 32 
Arguments: (x : UInt64)
Goal: x.toUInt32.toNat = x.toNat % 2 ^ 32
-- UInt64.toNat_zero
theorem UInt64.toNat_zero : (0 : UInt64).toNat = 0 
Goal: UInt64.toNat 0 = 0
-- UInt64.toNat_add
theorem UInt64.toNat_add (x y : UInt64) : (x + y).toNat = (x.toNat + y.toNat) % UInt64.size 
Arguments: (x y : UInt64)
Goal: (x + y).toNat = (x.toNat + y.toNat) % UInt64.size
-- UInt64.toNat_sub
theorem UInt64.toNat_sub (x y : UInt64) :
    (x - y).toNat = (UInt64.size - y.toNat + x.toNat) % UInt64.size 
Arguments: (x y : UInt64)
Goal: (x - y).toNat = (UInt64.size - y.toNat + x.toNat) % UInt64.size
-- UInt64.toNat_mul
theorem UInt64.toNat_mul (x y : UInt64) : (x * y).toNat = (x.toNat * y.toNat) % UInt64.size 
Arguments: (x y : UInt64)
Goal: (x * y).toNat = x.toNat * y.toNat % UInt64.size
-- UInt64.toNat_div
theorem UInt64.toNat_div (x y : UInt64) : (x / y).toNat = x.toNat / y.toNat 
Arguments: (x y : UInt64)
Goal: (x / y).toNat = x.toNat / y.toNat
-- UInt64.toNat_mod
theorem UInt64.toNat_mod (x y : UInt64) : (x % y).toNat = x.toNat % y.toNat 
Arguments: (x y : UInt64)
Goal: (x % y).toNat = x.toNat % y.toNat
-- UInt64.toNat_modn
theorem UInt64.toNat_modn (x : UInt64) (n) : (x.modn n).toNat = x.toNat % n 
Arguments: (x : UInt64) (n : Nat)
Goal: (x.modn n).toNat = x.toNat % n