ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.div2_bit
@[simp]
theorem div2_bit (b n) : div2 (bit b n) = n 
Arguments: (b : Bool) (n : ℤ)
Goal: (Int.bit b n).div2 = n
-- Nat.cast_sub
@[simp, norm_cast]
theorem cast_sub {m n} (h : m ≤ n) : ((n - m : ℕ) : R) = n - m 
Arguments: {R : Type u} [AddGroupWithOne R] {m n : ℕ} (h : m ≤ n)
Goal: ↑(n - m) = ↑n - ↑m
-- Nat.cast_pred
@[simp, norm_cast]
theorem cast_pred : ∀ {n}, 0 < n → ((n - 1 : ℕ) : R) = n - 1
  
Arguments: {R : Type u} [AddGroupWithOne R] {n : ℕ}
Goal: 0 < n → ↑(n - 1) = ↑n - 1
-- Int.cast_negSucc
@[simp, norm_cast squash]
theorem cast_negSucc (n : ℕ) : (-[n+1] : R) = -(n + 1 : ℕ) 
Arguments: {R : Type u} [AddGroupWithOne R] (n : ℕ)
Goal: ↑(Int.negSucc n) = -↑(n + 1)
-- Int.cast_zero
@[simp, norm_cast]
theorem cast_zero : ((0 : ℤ) : R) = 0 
Arguments: {R : Type u} [AddGroupWithOne R]
Goal: ↑0 = 0
-- Int.cast_natCast
@[simp high, nolint simpNF, norm_cast]
theorem cast_natCast (n : ℕ) : ((n : ℤ) : R) = n 
Arguments: {R : Type u} [AddGroupWithOne R] (n : ℕ)
Goal: ↑↑n = ↑n
-- Int.cast_ofNat
@[simp, norm_cast]
theorem cast_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n) : ℤ) : R) = OfNat.ofNat n 
Arguments: {R : Type u} [AddGroupWithOne R] (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Int.cast_one
@[simp, norm_cast]
theorem cast_one : ((1 : ℤ) : R) = 1 
Arguments: {R : Type u} [AddGroupWithOne R]
Goal: ↑1 = 1
-- Int.cast_neg
@[simp, norm_cast]
theorem cast_neg : ∀ n, ((-n : ℤ) : R) = -n
  
Arguments: {R : Type u} [AddGroupWithOne R] (n : ℤ)
Goal: ↑(-n) = -↑n
-- Int.cast_subNatNat
@[simp, norm_cast]
theorem cast_subNatNat (m n) : ((Int.subNatNat m n : ℤ) : R) = m - n 
Arguments: {R : Type u} [AddGroupWithOne R] (m n : ℕ)
Goal: ↑(Int.subNatNat m n) = ↑m - ↑n
-- Int.cast_negOfNat
@[simp]
theorem cast_negOfNat (n : ℕ) : ((negOfNat n : ℤ) : R) = -n 
Arguments: {R : Type u} [AddGroupWithOne R] (n : ℕ)
Goal: ↑(Int.negOfNat n) = -↑n
-- Int.cast_add
@[simp, norm_cast]
theorem cast_add : ∀ m n, ((m + n : ℤ) : R) = m + n
  
Arguments: {R : Type u} [AddGroupWithOne R] (m n : ℤ)
Goal: ↑(m + n) = ↑m + ↑n
-- Int.cast_sub
@[simp, norm_cast]
theorem cast_sub (m n) : ((m - n : ℤ) : R) = m - n 
Arguments: {R : Type u} [AddGroupWithOne R] (m n : ℤ)
Goal: ↑(m - n) = ↑m - ↑n
-- Int.cast_two
theorem cast_two : ((2 : ℤ) : R) = 2 
Arguments: {R : Type u} [AddGroupWithOne R]
Goal: ↑2 = 2
-- Int.cast_three
theorem cast_three : ((3 : ℤ) : R) = 3 
Arguments: {R : Type u} [AddGroupWithOne R]
Goal: ↑3 = 3
-- Int.cast_four
theorem cast_four : ((4 : ℤ) : R) = 4 
Arguments: {R : Type u} [AddGroupWithOne R]
Goal: ↑4 = 4
-- AddGroupWithOne.intCast_negSucc
class AddGroupWithOne (R : Type u) extends IntCast R, AddMonoidWithOne R, AddGroup R where
    intCast := Int.castDef
    intCast_ofNat : ∀ n : ℕ, intCast (n : ℕ) = Nat.cast n := by intros; rfl
    intCast_negSucc : ∀ n : ℕ, intCast (Int.negSucc n) = - Nat.cast (n + 1) := by intros; rfl
Arguments: {R : Type u} [self : AddGroupWithOne R] (n : ℕ)
Goal: IntCast.intCast (Int.negSucc n) = -↑(n + 1)
-- AddGroupWithOne.intCast_ofNat
class AddGroupWithOne (R : Type u) extends IntCast R, AddMonoidWithOne R, AddGroup R where
    intCast := Int.castDef
    intCast_ofNat : ∀ n : ℕ, intCast (n : ℕ) = Nat.cast n := by intros; rfl
    intCast_negSucc : ∀ n : ℕ, intCast (Int.negSucc n) = - Nat.cast (n + 1) := by intros; rfl
Arguments: {R : Type u} [self : AddGroupWithOne R] (n : ℕ)
Goal: IntCast.intCast ↑n = ↑n
-- Int.cast_neg_natCast
@[norm_cast]
theorem cast_neg_natCast {R} [DivisionRing R] (n : ℕ) : ((-n : ℤ) : R) = -n 
Arguments: {R : Type u_2} [DivisionRing R] (n : ℕ)
Goal: ↑(-↑n) = -↑n
-- Int.cast_div
@[simp]
theorem cast_div [DivisionRing α] {m n : ℤ} (n_dvd : n ∣ m) (hn : (n : α) ≠ 0) :
    ((m / n : ℤ) : α) = m / n 
Arguments: {α : Type u_1} [DivisionRing α] {m n : ℤ} (n_dvd : n ∣ m) (hn : ↑n ≠ 0)
Goal: ↑(m / n) = ↑m / ↑n
-- Sum.LiftRel.refl
@[refl]
theorem LiftRel.refl [IsRefl α r] [IsRefl β s] : ∀ x, LiftRel r s x x
  
Arguments: {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [IsRefl α r] [IsRefl β s] (x : α ⊕ β)
Goal: Sum.LiftRel r s x x
-- Sum.LiftRel.trans
@[trans]
theorem LiftRel.trans [IsTrans α r] [IsTrans β s] :
    ∀ {a b c}, LiftRel r s a b → LiftRel r s b c → LiftRel r s a c
  
Arguments: {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [IsTrans α r] [IsTrans β s] {a b c : α ⊕ β}
Goal: Sum.LiftRel r s a b → Sum.LiftRel r s b c → Sum.LiftRel r s a c
-- Sum.le_def
theorem le_def [LE α] [LE β] {a b : α ⊕ β} : a ≤ b ↔ LiftRel (· ≤ ·) (· ≤ ·) a b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : α ⊕ β}
Goal: a ≤ b ↔ Sum.LiftRel (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) a b
-- Sum.lt_def
theorem lt_def [LT α] [LT β] {a b : α ⊕ β} : a < b ↔ LiftRel (· < ·) (· < ·) a b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : α ⊕ β}
Goal: a < b ↔ Sum.LiftRel (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) a b
-- Sum.inl_le_inl_iff
@[simp]
theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : (inl a : α ⊕ β) ≤ inl b ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : α}
Goal: Sum.inl a ≤ Sum.inl b ↔ a ≤ b
-- Sum.inr_le_inr_iff
@[simp]
theorem inr_le_inr_iff [LE α] [LE β] {a b : β} : (inr a : α ⊕ β) ≤ inr b ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : β}
Goal: Sum.inr a ≤ Sum.inr b ↔ a ≤ b
-- Sum.inl_lt_inl_iff
@[simp]
theorem inl_lt_inl_iff [LT α] [LT β] {a b : α} : (inl a : α ⊕ β) < inl b ↔ a < b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : α}
Goal: Sum.inl a < Sum.inl b ↔ a < b
-- Sum.inr_lt_inr_iff
@[simp]
theorem inr_lt_inr_iff [LT α] [LT β] {a b : β} : (inr a : α ⊕ β) < inr b ↔ a < b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : β}
Goal: Sum.inr a < Sum.inr b ↔ a < b
-- Sum.not_inl_le_inr
@[simp]
theorem not_inl_le_inr [LE α] [LE β] {a : α} {b : β} : ¬inl b ≤ inr a 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a : α} {b : β}
Goal: ¬Sum.inl b ≤ Sum.inr a
-- Sum.not_inl_lt_inr
@[simp]
theorem not_inl_lt_inr [LT α] [LT β] {a : α} {b : β} : ¬inl b < inr a 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a : α} {b : β}
Goal: ¬Sum.inl b < Sum.inr a
-- Sum.not_inr_le_inl
@[simp]
theorem not_inr_le_inl [LE α] [LE β] {a : α} {b : β} : ¬inr b ≤ inl a 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a : α} {b : β}
Goal: ¬Sum.inr b ≤ Sum.inl a
-- Sum.not_inr_lt_inl
@[simp]
theorem not_inr_lt_inl [LT α] [LT β] {a : α} {b : β} : ¬inr b < inl a 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a : α} {b : β}
Goal: ¬Sum.inr b < Sum.inl a
-- Sum.inl_mono
theorem inl_mono : Monotone (inl : α → α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: Monotone Sum.inl
-- Sum.inr_mono
theorem inr_mono : Monotone (inr : β → α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: Monotone Sum.inr
-- Sum.inl_strictMono
theorem inl_strictMono : StrictMono (inl : α → α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: StrictMono Sum.inl
-- Sum.inr_strictMono
theorem inr_strictMono : StrictMono (inr : β → α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: StrictMono Sum.inr
-- Sum.noMinOrder_iff
@[simp]
theorem noMinOrder_iff [LT α] [LT β] : NoMinOrder (α ⊕ β) ↔ NoMinOrder α ∧ NoMinOrder β 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β]
Goal: NoMinOrder (α ⊕ β) ↔ NoMinOrder α ∧ NoMinOrder β
-- Sum.noMaxOrder_iff
@[simp]
theorem noMaxOrder_iff [LT α] [LT β] : NoMaxOrder (α ⊕ β) ↔ NoMaxOrder α ∧ NoMaxOrder β 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β]
Goal: NoMaxOrder (α ⊕ β) ↔ NoMaxOrder α ∧ NoMaxOrder β
-- Sum.denselyOrdered_iff
@[simp]
theorem denselyOrdered_iff [LT α] [LT β] :
    DenselyOrdered (α ⊕ β) ↔ DenselyOrdered α ∧ DenselyOrdered β 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β]
Goal: DenselyOrdered (α ⊕ β) ↔ DenselyOrdered α ∧ DenselyOrdered β
-- Sum.swap_le_swap_iff
@[simp]
theorem swap_le_swap_iff [LE α] [LE β] {a b : α ⊕ β} : a.swap ≤ b.swap ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : α ⊕ β}
Goal: a.swap ≤ b.swap ↔ a ≤ b
-- Sum.swap_lt_swap_iff
@[simp]
theorem swap_lt_swap_iff [LT α] [LT β] {a b : α ⊕ β} : a.swap < b.swap ↔ a < b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : α ⊕ β}
Goal: a.swap < b.swap ↔ a < b
-- Sum.Lex.toLex_le_toLex
@[simp]
theorem toLex_le_toLex [LE α] [LE β] {a b : α ⊕ β} :
    toLex a ≤ toLex b ↔ Lex (· ≤ ·) (· ≤ ·) a b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : α ⊕ β}
Goal: toLex a ≤ toLex b ↔ Sum.Lex (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) a b
-- Sum.Lex.toLex_lt_toLex
@[simp]
theorem toLex_lt_toLex [LT α] [LT β] {a b : α ⊕ β} :
    toLex a < toLex b ↔ Lex (· < ·) (· < ·) a b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : α ⊕ β}
Goal: toLex a < toLex b ↔ Sum.Lex (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) a b
-- Sum.Lex.le_def
theorem le_def [LE α] [LE β] {a b : α ⊕ₗ β} : a ≤ b ↔ Lex (· ≤ ·) (· ≤ ·) (ofLex a) (ofLex b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : Lex (α ⊕ β)}
Goal: a ≤ b ↔ Sum.Lex (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) (ofLex a) (ofLex b)
-- Sum.Lex.lt_def
theorem lt_def [LT α] [LT β] {a b : α ⊕ₗ β} : a < b ↔ Lex (· < ·) (· < ·) (ofLex a) (ofLex b) 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : Lex (α ⊕ β)}
Goal: a < b ↔ Sum.Lex (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) (ofLex a) (ofLex b)
-- Sum.Lex.inl_le_inl_iff
theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : toLex (inl a : α ⊕ β) ≤ toLex (inl b) ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : α}
Goal: toLex (Sum.inl a) ≤ toLex (Sum.inl b) ↔ a ≤ b
-- Sum.Lex.inr_le_inr_iff
theorem inr_le_inr_iff [LE α] [LE β] {a b : β} : toLex (inr a : α ⊕ β) ≤ toLex (inr b) ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a b : β}
Goal: toLex (Sum.inr a) ≤ toLex (Sum.inr b) ↔ a ≤ b
-- Sum.Lex.inl_lt_inl_iff
theorem inl_lt_inl_iff [LT α] [LT β] {a b : α} : toLex (inl a : α ⊕ β) < toLex (inl b) ↔ a < b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : α}
Goal: toLex (Sum.inl a) < toLex (Sum.inl b) ↔ a < b
-- Sum.Lex.inr_lt_inr_iff
theorem inr_lt_inr_iff [LT α] [LT β] {a b : β} : toLex (inr a : α ⊕ₗ β) < toLex (inr b) ↔ a < b 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a b : β}
Goal: toLex (Sum.inr a) < toLex (Sum.inr b) ↔ a < b
-- Sum.Lex.inl_le_inr
theorem inl_le_inr [LE α] [LE β] (a : α) (b : β) : toLex (inl a) ≤ toLex (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (a : α) (b : β)
Goal: toLex (Sum.inl a) ≤ toLex (Sum.inr b)
-- Sum.Lex.inl_lt_inr
theorem inl_lt_inr [LT α] [LT β] (a : α) (b : β) : toLex (inl a) < toLex (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (a : α) (b : β)
Goal: toLex (Sum.inl a) < toLex (Sum.inr b)
-- Sum.Lex.not_inr_le_inl
theorem not_inr_le_inl [LE α] [LE β] {a : α} {b : β} : ¬toLex (inr b) ≤ toLex (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] {a : α} {b : β}
Goal: ¬toLex (Sum.inr b) ≤ toLex (Sum.inl a)
-- Sum.Lex.not_inr_lt_inl
theorem not_inr_lt_inl [LT α] [LT β] {a : α} {b : β} : ¬toLex (inr b) < toLex (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {a : α} {b : β}
Goal: ¬toLex (Sum.inr b) < toLex (Sum.inl a)
-- Sum.Lex.toLex_mono
theorem toLex_mono : Monotone (@toLex (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: Monotone ⇑toLex
-- Sum.Lex.toLex_strictMono
theorem toLex_strictMono : StrictMono (@toLex (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: StrictMono ⇑toLex
-- Sum.Lex.inl_mono
theorem inl_mono : Monotone (toLex ∘ inl : α → α ⊕ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: Monotone (⇑toLex ∘ Sum.inl)
-- Sum.Lex.inr_mono
theorem inr_mono : Monotone (toLex ∘ inr : β → α ⊕ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: Monotone (⇑toLex ∘ Sum.inr)
-- Sum.Lex.inl_strictMono
theorem inl_strictMono : StrictMono (toLex ∘ inl : α → α ⊕ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: StrictMono (⇑toLex ∘ Sum.inl)
-- Sum.Lex.inr_strictMono
theorem inr_strictMono : StrictMono (toLex ∘ inr : β → α ⊕ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β]
Goal: StrictMono (⇑toLex ∘ Sum.inr)
-- Sum.Lex.inl_bot
@[simp]
theorem inl_bot [LE α] [OrderBot α] [LE β] : toLex (inl ⊥ : α ⊕ β) = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [OrderBot α] [LE β]
Goal: toLex (Sum.inl ⊥) = ⊥
-- Sum.Lex.inr_top
@[simp]
theorem inr_top [LE α] [LE β] [OrderTop β] : toLex (inr ⊤ : α ⊕ β) = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] [OrderTop β]
Goal: toLex (Sum.inr ⊤) = ⊤
-- OrderIso.sumComm_apply
@[simps! apply]
def sumComm (α β : Type*) [LE α] [LE β] : α ⊕ β ≃o β ⊕ α 
Arguments: (α : Type u_5) (β : Type u_6) [LE α] [LE β]
Goal: ∀ (a : α ⊕ β), (OrderIso.sumComm α β) a = a.swap
-- OrderIso.sumComm_symm
@[simp]
theorem sumComm_symm (α β : Type*) [LE α] [LE β] :
    (OrderIso.sumComm α β).symm = OrderIso.sumComm β α 
Arguments: (α : Type u_5) (β : Type u_6) [LE α] [LE β]
Goal: (OrderIso.sumComm α β).symm = OrderIso.sumComm β α
-- OrderIso.sumAssoc_apply_inl_inl
@[simp]
theorem sumAssoc_apply_inl_inl : sumAssoc α β γ (inl (inl a)) = inl a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (a : α)
Goal: (OrderIso.sumAssoc α β γ) (Sum.inl (Sum.inl a)) = Sum.inl a
-- OrderIso.sumAssoc_apply_inl_inr
@[simp]
theorem sumAssoc_apply_inl_inr : sumAssoc α β γ (inl (inr b)) = inr (inl b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (b : β)
Goal: (OrderIso.sumAssoc α β γ) (Sum.inl (Sum.inr b)) = Sum.inr (Sum.inl b)
-- OrderIso.sumAssoc_apply_inr
@[simp]
theorem sumAssoc_apply_inr : sumAssoc α β γ (inr c) = inr (inr c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (c : γ)
Goal: (OrderIso.sumAssoc α β γ) (Sum.inr c) = Sum.inr (Sum.inr c)
-- OrderIso.sumAssoc_symm_apply_inl
@[simp]
theorem sumAssoc_symm_apply_inl : (sumAssoc α β γ).symm (inl a) = inl (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (a : α)
Goal: (OrderIso.sumAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a)
-- OrderIso.sumAssoc_symm_apply_inr_inl
@[simp]
theorem sumAssoc_symm_apply_inr_inl : (sumAssoc α β γ).symm (inr (inl b)) = inl (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (b : β)
Goal: (OrderIso.sumAssoc α β γ).symm (Sum.inr (Sum.inl b)) = Sum.inl (Sum.inr b)
-- OrderIso.sumAssoc_symm_apply_inr_inr
@[simp]
theorem sumAssoc_symm_apply_inr_inr : (sumAssoc α β γ).symm (inr (inr c)) = inr c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (c : γ)
Goal: (OrderIso.sumAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c
-- OrderIso.sumDualDistrib_inl
@[simp]
theorem sumDualDistrib_inl : sumDualDistrib α β (toDual (inl a)) = inl (toDual a) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (a : α)
Goal: (OrderIso.sumDualDistrib α β) (OrderDual.toDual (Sum.inl a)) = Sum.inl (OrderDual.toDual a)
-- OrderIso.sumDualDistrib_inr
@[simp]
theorem sumDualDistrib_inr : sumDualDistrib α β (toDual (inr b)) = inr (toDual b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (b : β)
Goal: (OrderIso.sumDualDistrib α β) (OrderDual.toDual (Sum.inr b)) = Sum.inr (OrderDual.toDual b)
-- OrderIso.sumDualDistrib_symm_inl
@[simp]
theorem sumDualDistrib_symm_inl : (sumDualDistrib α β).symm (inl (toDual a)) = toDual (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (a : α)
Goal: (OrderIso.sumDualDistrib α β).symm (Sum.inl (OrderDual.toDual a)) = OrderDual.toDual (Sum.inl a)
-- OrderIso.sumDualDistrib_symm_inr
@[simp]
theorem sumDualDistrib_symm_inr : (sumDualDistrib α β).symm (inr (toDual b)) = toDual (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (b : β)
Goal: (OrderIso.sumDualDistrib α β).symm (Sum.inr (OrderDual.toDual b)) = OrderDual.toDual (Sum.inr b)
-- OrderIso.sumLexAssoc_apply_inl_inl
@[simp]
theorem sumLexAssoc_apply_inl_inl :
    sumLexAssoc α β γ (toLex <| inl <| toLex <| inl a) = toLex (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (a : α)
Goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inl a)))) = toLex (Sum.inl a)
-- OrderIso.sumLexAssoc_apply_inl_inr
@[simp]
theorem sumLexAssoc_apply_inl_inr :
    sumLexAssoc α β γ (toLex <| inl <| toLex <| inr b) = toLex (inr <| toLex <| inl b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (b : β)
Goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inr b)))) = toLex (Sum.inr (toLex (Sum.inl b)))
-- OrderIso.sumLexAssoc_apply_inr
@[simp]
theorem sumLexAssoc_apply_inr :
    sumLexAssoc α β γ (toLex <| inr c) = toLex (inr <| toLex <| inr c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (c : γ)
Goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inr c)) = toLex (Sum.inr (toLex (Sum.inr c)))
-- OrderIso.sumLexAssoc_symm_apply_inl
@[simp]
theorem sumLexAssoc_symm_apply_inl : (sumLexAssoc α β γ).symm (inl a) = inl (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (a : α)
Goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a)
-- OrderIso.sumLexAssoc_symm_apply_inr_inl
@[simp]
theorem sumLexAssoc_symm_apply_inr_inl : (sumLexAssoc α β γ).symm (inr (inl b)) = inl (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (b : β)
Goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inr (Sum.inl b)) = Sum.inl (Sum.inr b)
-- OrderIso.sumLexAssoc_symm_apply_inr_inr
@[simp]
theorem sumLexAssoc_symm_apply_inr_inr : (sumLexAssoc α β γ).symm (inr (inr c)) = inr c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [LE α] [LE β] [LE γ] (c : γ)
Goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c
-- OrderIso.sumLexDualAntidistrib_inl
@[simp]
theorem sumLexDualAntidistrib_inl :
    sumLexDualAntidistrib α β (toDual (inl a)) = inr (toDual a) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (a : α)
Goal: (OrderIso.sumLexDualAntidistrib α β) (OrderDual.toDual (Sum.inl a)) = Sum.inr (OrderDual.toDual a)
-- OrderIso.sumLexDualAntidistrib_inr
@[simp]
theorem sumLexDualAntidistrib_inr :
    sumLexDualAntidistrib α β (toDual (inr b)) = inl (toDual b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (b : β)
Goal: (OrderIso.sumLexDualAntidistrib α β) (OrderDual.toDual (Sum.inr b)) = Sum.inl (OrderDual.toDual b)
-- OrderIso.sumLexDualAntidistrib_symm_inl
@[simp]
theorem sumLexDualAntidistrib_symm_inl :
    (sumLexDualAntidistrib α β).symm (inl (toDual b)) = toDual (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (b : β)
Goal: (OrderIso.sumLexDualAntidistrib α β).symm (Sum.inl (OrderDual.toDual b)) = OrderDual.toDual (Sum.inr b)
-- OrderIso.sumLexDualAntidistrib_symm_inr
@[simp]
theorem sumLexDualAntidistrib_symm_inr :
    (sumLexDualAntidistrib α β).symm (inr (toDual a)) = toDual (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} [LE α] [LE β] (a : α)
Goal: (OrderIso.sumLexDualAntidistrib α β).symm (Sum.inr (OrderDual.toDual a)) = OrderDual.toDual (Sum.inl a)
-- WithBot.orderIsoPUnitSumLex_bot
@[simp]
theorem orderIsoPUnitSumLex_bot : @orderIsoPUnitSumLex α _ ⊥ = toLex (inl PUnit.unit) 
Arguments: {α : Type u_1} [LE α]
Goal: WithBot.orderIsoPUnitSumLex ⊥ = toLex (Sum.inl PUnit.unit)
-- WithBot.orderIsoPUnitSumLex_toLex
@[simp]
theorem orderIsoPUnitSumLex_toLex (a : α) : orderIsoPUnitSumLex ↑a = toLex (inr a) 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: WithBot.orderIsoPUnitSumLex ↑a = toLex (Sum.inr a)
-- WithBot.orderIsoPUnitSumLex_symm_inl
@[simp]
theorem orderIsoPUnitSumLex_symm_inl (x : PUnit) :
    (@orderIsoPUnitSumLex α _).symm (toLex <| inl x) = ⊥ 
Arguments: {α : Type u_1} [LE α] (x : PUnit.{u_5 + 1})
Goal: WithBot.orderIsoPUnitSumLex.symm (toLex (Sum.inl x)) = ⊥
-- WithBot.orderIsoPUnitSumLex_symm_inr
@[simp]
theorem orderIsoPUnitSumLex_symm_inr (a : α) : orderIsoPUnitSumLex.symm (toLex <| inr a) = a 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: WithBot.orderIsoPUnitSumLex.symm (toLex (Sum.inr a)) = ↑a
-- WithTop.orderIsoSumLexPUnit_top
@[simp]
theorem orderIsoSumLexPUnit_top : @orderIsoSumLexPUnit α _ ⊤ = toLex (inr PUnit.unit) 
Arguments: {α : Type u_1} [LE α]
Goal: WithTop.orderIsoSumLexPUnit ⊤ = toLex (Sum.inr PUnit.unit)
-- WithTop.orderIsoSumLexPUnit_toLex
@[simp]
theorem orderIsoSumLexPUnit_toLex (a : α) : orderIsoSumLexPUnit ↑a = toLex (inl a) 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: WithTop.orderIsoSumLexPUnit ↑a = toLex (Sum.inl a)
-- WithTop.orderIsoSumLexPUnit_symm_inr
@[simp]
theorem orderIsoSumLexPUnit_symm_inr (x : PUnit) :
    (@orderIsoSumLexPUnit α _).symm (toLex <| inr x) = ⊤ 
Arguments: {α : Type u_1} [LE α] (x : PUnit.{u_5 + 1})
Goal: WithTop.orderIsoSumLexPUnit.symm (toLex (Sum.inr x)) = ⊤
-- WithTop.orderIsoSumLexPUnit_symm_inl
@[simp]
theorem orderIsoSumLexPUnit_symm_inl (a : α) : orderIsoSumLexPUnit.symm (toLex <| inl a) = a 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: WithTop.orderIsoSumLexPUnit.symm (toLex (Sum.inl a)) = ↑a
-- Prod.fst_intCast
@[simp]
theorem fst_intCast (n : ℤ) : (n : α × β).fst = n 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroupWithOne α] [AddGroupWithOne β] (n : ℤ)
Goal: (↑n).1 = ↑n
-- Prod.snd_intCast
@[simp]
theorem snd_intCast (n : ℤ) : (n : α × β).snd = n 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroupWithOne α] [AddGroupWithOne β] (n : ℤ)
Goal: (↑n).2 = ↑n
-- Int.isUnit_iff_abs_eq
theorem isUnit_iff_abs_eq {x : ℤ} : IsUnit x ↔ abs x = 1 
Arguments: {x : ℤ}
Goal: IsUnit x ↔ |x| = 1
-- Int.isUnit_sq
theorem isUnit_sq {a : ℤ} (ha : IsUnit a) : a ^ 2 = 1 
Arguments: {a : ℤ} (ha : IsUnit a)
Goal: a ^ 2 = 1
-- Int.units_sq
@[simp]
theorem units_sq (u : ℤˣ) : u ^ 2 = 1 
Arguments: (u : ℤˣ)
Goal: u ^ 2 = 1
-- Int.units_mul_self
@[simp]
theorem units_mul_self (u : ℤˣ) : u * u = 1 
Arguments: (u : ℤˣ)
Goal: u * u = 1
-- Int.units_inv_eq_self
@[simp]
theorem units_inv_eq_self (u : ℤˣ) : u⁻¹ = u 
Arguments: (u : ℤˣ)
Goal: u⁻¹ = u
-- Int.units_div_eq_mul
theorem units_div_eq_mul (u₁ u₂ : ℤˣ) : u₁ / u₂ = u₁ * u₂ 
Arguments: (u₁ u₂ : ℤˣ)
Goal: u₁ / u₂ = u₁ * u₂
-- Int.units_coe_mul_self
@[simp]
theorem units_coe_mul_self (u : ℤˣ) : (u * u : ℤ) = 1 
Arguments: (u : ℤˣ)
Goal: ↑u * ↑u = 1
-- Int.neg_one_pow_ne_zero
theorem neg_one_pow_ne_zero {n : ℕ} : (-1 : ℤ) ^ n ≠ 0 
Arguments: {n : ℕ}
Goal: (-1) ^ n ≠ 0
-- Int.sq_eq_one_of_sq_lt_four
theorem sq_eq_one_of_sq_lt_four {x : ℤ} (h1 : x ^ 2 < 4) (h2 : x ≠ 0) : x ^ 2 = 1 
Arguments: {x : ℤ} (h1 : x ^ 2 < 4) (h2 : x ≠ 0)
Goal: x ^ 2 = 1
-- Int.sq_eq_one_of_sq_le_three
theorem sq_eq_one_of_sq_le_three {x : ℤ} (h1 : x ^ 2 ≤ 3) (h2 : x ≠ 0) : x ^ 2 = 1 
Arguments: {x : ℤ} (h1 : x ^ 2 ≤ 3) (h2 : x ≠ 0)
Goal: x ^ 2 = 1
-- Int.units_pow_eq_pow_mod_two
theorem units_pow_eq_pow_mod_two (u : ℤˣ) (n : ℕ) : u ^ n = u ^ (n % 2) 
Arguments: (u : ℤˣ) (n : ℕ)
Goal: u ^ n = u ^ (n % 2)
-- Int.natAbs_eq_iff_mul_self_eq
theorem natAbs_eq_iff_mul_self_eq {a b : ℤ} : a.natAbs = b.natAbs ↔ a * a = b * b 
Arguments: {a b : ℤ}
Goal: a.natAbs = b.natAbs ↔ a * a = b * b
-- Int.natAbs_lt_iff_mul_self_lt
theorem natAbs_lt_iff_mul_self_lt {a b : ℤ} : a.natAbs < b.natAbs ↔ a * a < b * b 
Arguments: {a b : ℤ}
Goal: a.natAbs < b.natAbs ↔ a * a < b * b
-- Int.natAbs_le_iff_mul_self_le
theorem natAbs_le_iff_mul_self_le {a b : ℤ} : a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b 
Arguments: {a b : ℤ}
Goal: a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b
-- Int.eq_zero_of_abs_lt_dvd
theorem eq_zero_of_abs_lt_dvd {m x : ℤ} (h1 : m ∣ x) (h2 : |x| < m) : x = 0 
Arguments: {m x : ℤ} (h1 : m ∣ x) (h2 : |x| < m)
Goal: x = 0
-- PFunctor.Approx.cofixA_eq_zero
theorem cofixA_eq_zero : ∀ x y : CofixA F 0, x = y
  
Arguments: (F : PFunctor.{u}) (x y : PFunctor.Approx.CofixA F 0)
Goal: x = y
-- PFunctor.Approx.approx_eta
theorem approx_eta {n : ℕ} (x : CofixA F (n + 1)) : x = CofixA.intro (head' x) (children' x) 
Arguments: {F : PFunctor.{u}} {n : ℕ} (x : PFunctor.Approx.CofixA F (n + 1))
Goal: x = PFunctor.Approx.CofixA.intro (PFunctor.Approx.head' x) (PFunctor.Approx.children' x)