ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.eq_of_mem_uIcc_of_mem_uIcc'
theorem eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [[a, c]] → c ∈ [[a, b]] → b = c 
Arguments: {α : Type u_2} [DistribLattice α] [LocallyFiniteOrder α] {a b c : α}
Goal: b ∈ [[a, c]] → c ∈ [[a, b]] → b = c
-- Finset.uIcc_injective_right
theorem uIcc_injective_right (a : α) : Injective fun b => [[b, a]] 
Arguments: {α : Type u_2} [DistribLattice α] [LocallyFiniteOrder α] (a : α)
Goal: Function.Injective fun b => [[b, a]]
-- Finset.uIcc_injective_left
theorem uIcc_injective_left (a : α) : Injective (uIcc a) 
Arguments: {α : Type u_2} [DistribLattice α] [LocallyFiniteOrder α] (a : α)
Goal: Function.Injective (Finset.uIcc a)
-- Finset.Icc_min_max
theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b : α}
Goal: Finset.Icc (min a b) (max a b) = [[a, b]]
-- Finset.uIcc_of_not_le
theorem uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b : α} (h : ¬a ≤ b)
Goal: [[a, b]] = Finset.Icc b a
-- Finset.uIcc_of_not_ge
theorem uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b : α} (h : ¬b ≤ a)
Goal: [[a, b]] = Finset.Icc a b
-- Finset.uIcc_eq_union
theorem uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b : α}
Goal: [[a, b]] = Finset.Icc a b ∪ Finset.Icc b a
-- Finset.mem_uIcc'
theorem mem_uIcc' : a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b c : α}
Goal: a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b
-- Finset.not_mem_uIcc_of_lt
theorem not_mem_uIcc_of_lt : c < a → c < b → c ∉ [[a, b]] 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b c : α}
Goal: c < a → c < b → c ∉ [[a, b]]
-- Finset.not_mem_uIcc_of_gt
theorem not_mem_uIcc_of_gt : a < c → b < c → c ∉ [[a, b]] 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b c : α}
Goal: a < c → b < c → c ∉ [[a, b]]
-- Finset.uIcc_subset_uIcc_iff_le
theorem uIcc_subset_uIcc_iff_le :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a₁ a₂ b₁ b₂ : α}
Goal: [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂
-- Finset.uIcc_subset_uIcc_union_uIcc
theorem uIcc_subset_uIcc_union_uIcc : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] 
Arguments: {α : Type u_2} [LinearOrder α] [LocallyFiniteOrder α] {a b c : α}
Goal: [[a, c]] ⊆ [[a, b]] ∪ [[b, c]]
-- transGen_wcovBy_of_le
lemma transGen_wcovBy_of_le [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x ≤ y) :
    TransGen (· ⩿ ·) x y 
Arguments: {α : Type u_2} [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x ≤ y)
Goal: Relation.TransGen (fun x x_1 => x ⩿ x_1) x y
-- le_iff_transGen_wcovBy
lemma le_iff_transGen_wcovBy [Preorder α] [LocallyFiniteOrder α] {x y : α} :
    x ≤ y ↔ TransGen (· ⩿ ·) x y 
Arguments: {α : Type u_2} [Preorder α] [LocallyFiniteOrder α] {x y : α}
Goal: x ≤ y ↔ Relation.TransGen (fun x x_1 => x ⩿ x_1) x y
-- le_iff_reflTransGen_covBy
lemma le_iff_reflTransGen_covBy [PartialOrder α] [LocallyFiniteOrder α] {x y : α} :
    x ≤ y ↔ ReflTransGen (· ⋖ ·) x y 
Arguments: {α : Type u_2} [PartialOrder α] [LocallyFiniteOrder α] {x y : α}
Goal: x ≤ y ↔ Relation.ReflTransGen (fun x x_1 => x ⋖ x_1) x y
-- transGen_covBy_of_lt
lemma transGen_covBy_of_lt [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x < y) :
    TransGen (· ⋖ ·) x y 
Arguments: {α : Type u_2} [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x < y)
Goal: Relation.TransGen (fun x x_1 => x ⋖ x_1) x y
-- lt_iff_transGen_covBy
lemma lt_iff_transGen_covBy [Preorder α] [LocallyFiniteOrder α] {x y : α} :
    x < y ↔ TransGen (· ⋖ ·) x y 
Arguments: {α : Type u_2} [Preorder α] [LocallyFiniteOrder α] {x y : α}
Goal: x < y ↔ Relation.TransGen (fun x x_1 => x ⋖ x_1) x y
-- monotone_iff_forall_wcovBy
lemma monotone_iff_forall_wcovBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Monotone f ↔ ∀ a b : α, a ⩿ b → f a ≤ f b 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: Monotone f ↔ ∀ (a b : α), a ⩿ b → f a ≤ f b
-- monotone_iff_forall_covBy
lemma monotone_iff_forall_covBy [PartialOrder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Monotone f ↔ ∀ a b : α, a ⋖ b → f a ≤ f b 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: Monotone f ↔ ∀ (a b : α), a ⋖ b → f a ≤ f b
-- strictMono_iff_forall_covBy
lemma strictMono_iff_forall_covBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : StrictMono f ↔ ∀ a b : α, a ⋖ b → f a < f b 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: StrictMono f ↔ ∀ (a b : α), a ⋖ b → f a < f b
-- antitone_iff_forall_wcovBy
lemma antitone_iff_forall_wcovBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Antitone f ↔ ∀ a b : α, a ⩿ b → f b ≤ f a 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: Antitone f ↔ ∀ (a b : α), a ⩿ b → f b ≤ f a
-- antitone_iff_forall_covBy
lemma antitone_iff_forall_covBy [PartialOrder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Antitone f ↔ ∀ a b : α, a ⋖ b → f b ≤ f a 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: Antitone f ↔ ∀ (a b : α), a ⋖ b → f b ≤ f a
-- strictAnti_iff_forall_covBy
lemma strictAnti_iff_forall_covBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : StrictAnti f ↔ ∀ a b : α, a ⋖ b → f b < f a 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [LocallyFiniteOrder α] [Preorder β] (f : α → β)
Goal: StrictAnti f ↔ ∀ (a b : α), a ⋖ b → f b < f a
-- Int.le.elim
theorem le.elim {a b : ℤ} (h : a ≤ b) {P : Prop} (h' : ∀ n : ℕ, a + ↑n = b → P) : P 
Arguments: {a b : ℤ} (h : a ≤ b) {P : Prop} (h' : ∀ (n : ℕ), a + ↑n = b → P)
Goal: P
-- Int.lt.elim
theorem lt.elim {a b : ℤ} (h : a < b) {P : Prop} (h' : ∀ n : ℕ, a + ↑(Nat.succ n) = b → P) : P 
Arguments: {a b : ℤ} (h : a < b) {P : Prop} (h' : ∀ (n : ℕ), a + ↑n.succ = b → P)
Goal: P
-- Int.neg_mul_eq_neg_mul_symm
theorem neg_mul_eq_neg_mul_symm (a b : ℤ) : -a * b = -(a * b) 
Arguments: (a b : ℤ)
Goal: -a * b = -(a * b)
-- Int.mul_neg_eq_neg_mul_symm
theorem mul_neg_eq_neg_mul_symm (a b : ℤ) : a * -b = -(a * b) 
Arguments: (a b : ℤ)
Goal: a * -b = -(a * b)
-- Int.eq_zero_or_eq_zero_of_mul_eq_zero
protected theorem eq_zero_or_eq_zero_of_mul_eq_zero {a b : ℤ} (h : a * b = 0) : a = 0 ∨ b = 0 
Arguments: {a b : ℤ} (h : a * b = 0)
Goal: a = 0 ∨ b = 0
-- Nat.eq_zero_of_mul_eq_zero
theorem eq_zero_of_mul_eq_zero : ∀ {n m : ℕ}, n * m = 0 → n = 0 ∨ m = 0
  
Arguments: {n m : ℕ}
Goal: n * m = 0 → n = 0 ∨ m = 0
-- Nat.one_eq_succ_zero
theorem one_eq_succ_zero : 1 = succ 0 
Goal: 1 = Nat.succ 0
-- Nat.strong_induction_on
@[elab_as_elim]
protected theorem strong_induction_on {p : Nat → Prop} (n : Nat)
    (h : ∀ n, (∀ m, m < n → p m) → p n) : p n 
Arguments: {p : ℕ → Prop} (n : ℕ) (h : ∀ (n : ℕ), (∀ (m : ℕ), m < n → p m) → p n)
Goal: p n
-- Nat.case_strong_induction_on
protected theorem case_strong_induction_on {p : Nat → Prop} (a : Nat) (hz : p 0)
    (hi : ∀ n, (∀ m, m ≤ n → p m) → p (succ n)) : p a 
Arguments: {p : ℕ → Prop} (a : ℕ) (hz : p 0) (hi : ∀ (n : ℕ), (∀ (m : ℕ), m ≤ n → p m) → p n.succ)
Goal: p a
-- Nat.cond_decide_mod_two
theorem cond_decide_mod_two (x : ℕ) [d : Decidable (x % 2 = 1)] :
    cond (@decide (x % 2 = 1) d) 1 0 = x % 2 
Arguments: (x : ℕ) [d : Decidable (x % 2 = 1)]
Goal: (bif decide (x % 2 = 1) then 1 else 0) = x % 2
-- WithBot.coe_injective
theorem coe_injective : Injective ((↑) : α → WithBot α) 
Arguments: {α : Type u_1}
Goal: Function.Injective WithBot.some
-- WithBot.coe_inj
@[simp, norm_cast]
theorem coe_inj : (a : WithBot α) = b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: ↑a = ↑b ↔ a = b
-- WithBot.forall
protected theorem «forall» {p : WithBot α → Prop} : (∀ x, p x) ↔ p ⊥ ∧ ∀ x : α, p x 
Arguments: {α : Type u_1} {p : WithBot α → Prop}
Goal: (∀ (x : WithBot α), p x) ↔ p ⊥ ∧ ∀ (x : α), p ↑x
-- WithBot.exists
protected theorem «exists» {p : WithBot α → Prop} : (∃ x, p x) ↔ p ⊥ ∨ ∃ x : α, p x 
Arguments: {α : Type u_1} {p : WithBot α → Prop}
Goal: (∃ x, p x) ↔ p ⊥ ∨ ∃ x, p ↑x
-- WithBot.none_eq_bot
theorem none_eq_bot : (none : WithBot α) = (⊥ : WithBot α) 
Arguments: {α : Type u_1}
Goal: none = ⊥
-- WithBot.some_eq_coe
theorem some_eq_coe (a : α) : (Option.some a : WithBot α) = (↑a : WithBot α) 
Arguments: {α : Type u_1} (a : α)
Goal: some a = ↑a
-- WithBot.bot_ne_coe
@[simp]
theorem bot_ne_coe : ⊥ ≠ (a : WithBot α) 
Arguments: {α : Type u_1} {a : α}
Goal: ⊥ ≠ ↑a
-- WithBot.coe_ne_bot
@[simp]
theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ 
Arguments: {α : Type u_1} {a : α}
Goal: ↑a ≠ ⊥
-- WithBot.recBotCoe_bot
@[simp]
theorem recBotCoe_bot {C : WithBot α → Sort*} (d : C ⊥) (f : ∀ a : α, C a) :
    @recBotCoe _ C d f ⊥ = d 
Arguments: {α : Type u_1} {C : WithBot α → Sort u_5} (d : C ⊥) (f : (a : α) → C ↑a)
Goal: WithBot.recBotCoe d f ⊥ = d
-- WithBot.recBotCoe_coe
@[simp]
theorem recBotCoe_coe {C : WithBot α → Sort*} (d : C ⊥) (f : ∀ a : α, C a) (x : α) :
    @recBotCoe _ C d f ↑x = f x 
Arguments: {α : Type u_1} {C : WithBot α → Sort u_5} (d : C ⊥) (f : (a : α) → C ↑a) (x : α)
Goal: WithBot.recBotCoe d f ↑x = f x
-- WithBot.unbot'_bot
@[simp]
theorem unbot'_bot {α} (d : α) : unbot' d ⊥ = d 
Arguments: {α : Type u_5} (d : α)
Goal: WithBot.unbot' d ⊥ = d
-- WithBot.unbot'_coe
@[simp]
theorem unbot'_coe {α} (d x : α) : unbot' d x = x 
Arguments: {α : Type u_5} (d x : α)
Goal: WithBot.unbot' d ↑x = x
-- WithBot.coe_eq_coe
theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: ↑a = ↑b ↔ a = b
-- WithBot.unbot'_eq_iff
theorem unbot'_eq_iff {d y : α} {x : WithBot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d 
Arguments: {α : Type u_1} {d y : α} {x : WithBot α}
Goal: WithBot.unbot' d x = y ↔ x = ↑y ∨ x = ⊥ ∧ y = d
-- WithBot.unbot'_eq_self_iff
@[simp] theorem unbot'_eq_self_iff {d : α} {x : WithBot α} : unbot' d x = d ↔ x = d ∨ x = ⊥ 
Arguments: {α : Type u_1} {d : α} {x : WithBot α}
Goal: WithBot.unbot' d x = d ↔ x = ↑d ∨ x = ⊥
-- WithBot.unbot'_eq_unbot'_iff
theorem unbot'_eq_unbot'_iff {d : α} {x y : WithBot α} :
    unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d 
Arguments: {α : Type u_1} {d : α} {x y : WithBot α}
Goal: WithBot.unbot' d x = WithBot.unbot' d y ↔ x = y ∨ x = ↑d ∧ y = ⊥ ∨ x = ⊥ ∧ y = ↑d
-- WithBot.map_bot
@[simp]
theorem map_bot (f : α → β) : map f ⊥ = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: WithBot.map f ⊥ = ⊥
-- WithBot.map_coe
@[simp]
theorem map_coe (f : α → β) (a : α) : map f a = f a 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : α)
Goal: WithBot.map f ↑a = ↑(f a)
-- WithBot.map_comm
theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ}
    (h : g₁ ∘ f₁ = g₂ ∘ f₂) (a : α) :
    map g₁ (map f₁ a) = map g₂ (map f₂ a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂) (a : α)
Goal: WithBot.map g₁ (WithBot.map f₁ ↑a) = WithBot.map g₂ (WithBot.map f₂ ↑a)
-- WithBot.map₂_coe_coe
lemma map₂_coe_coe (f : α → β → γ) (a : α) (b : β) : map₂ f a b = f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (b : β)
Goal: WithBot.map₂ f ↑a ↑b = ↑(f a b)
-- WithBot.map₂_bot_left
@[simp] lemma map₂_bot_left (f : α → β → γ) (b) : map₂ f ⊥ b = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (b : WithBot β)
Goal: WithBot.map₂ f ⊥ b = ⊥
-- WithBot.map₂_bot_right
@[simp] lemma map₂_bot_right (f : α → β → γ) (a) : map₂ f a ⊥ = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : WithBot α)
Goal: WithBot.map₂ f a ⊥ = ⊥
-- WithBot.map₂_coe_left
@[simp] lemma map₂_coe_left (f : α → β → γ) (a : α) (b) : map₂ f a b = b.map fun b ↦ f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (b : WithBot β)
Goal: WithBot.map₂ f (↑a) b = WithBot.map (fun b => f a b) b
-- WithBot.map₂_coe_right
@[simp] lemma map₂_coe_right (f : α → β → γ) (a) (b : β) : map₂ f a b = a.map (f · b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : WithBot α) (b : β)
Goal: WithBot.map₂ f a ↑b = WithBot.map (fun x => f x b) a
-- WithBot.map₂_eq_bot_iff
@[simp] lemma map₂_eq_bot_iff {f : α → β → γ} {a : WithBot α} {b : WithBot β} :
    map₂ f a b = ⊥ ↔ a = ⊥ ∨ b = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {a : WithBot α} {b : WithBot β}
Goal: WithBot.map₂ f a b = ⊥ ↔ a = ⊥ ∨ b = ⊥
-- WithBot.ne_bot_iff_exists
lemma ne_bot_iff_exists {x : WithBot α} : x ≠ ⊥ ↔ ∃ a : α, ↑a = x 
Arguments: {α : Type u_1} {x : WithBot α}
Goal: x ≠ ⊥ ↔ ∃ a, ↑a = x
-- WithBot.forall_ne_iff_eq_bot
lemma forall_ne_iff_eq_bot {x : WithBot α} : (∀ a : α, ↑a ≠ x) ↔ x = ⊥ 
Arguments: {α : Type u_1} {x : WithBot α}
Goal: (∀ (a : α), ↑a ≠ x) ↔ x = ⊥
-- WithBot.coe_unbot
@[simp] lemma coe_unbot : ∀ (x : WithBot α) hx, x.unbot hx = x 
Arguments: {α : Type u_1} (x : WithBot α) (hx : x ≠ ⊥)
Goal: ↑(x.unbot hx) = x
-- WithBot.unbot_coe
@[simp]
theorem unbot_coe (x : α) (h : (x : WithBot α) ≠ ⊥ := coe_ne_bot) : (x : WithBot α).unbot h = x 
Arguments: {α : Type u_1} (x : α) (h : ↑x ≠ ⊥ := ⋯)
Goal: (↑x).unbot h = x
-- WithBot.coe_top
@[simp, norm_cast] lemma coe_top [Top α] : ((⊤ : α) : WithBot α) = ⊤ 
Arguments: {α : Type u_1} [Top α]
Goal: ↑⊤ = ⊤
-- WithBot.coe_eq_top
@[simp, norm_cast] lemma coe_eq_top [Top α] {a : α} : (a : WithBot α) = ⊤ ↔ a = ⊤ 
Arguments: {α : Type u_1} [Top α] {a : α}
Goal: ↑a = ⊤ ↔ a = ⊤
-- WithBot.top_eq_coe
@[simp, norm_cast] lemma top_eq_coe [Top α] {a : α} : ⊤ = (a : WithBot α) ↔ ⊤ = a 
Arguments: {α : Type u_1} [Top α] {a : α}
Goal: ⊤ = ↑a ↔ ⊤ = a
-- WithBot.coe_le_coe
@[simp, norm_cast]
theorem coe_le_coe : (a : WithBot α) ≤ b ↔ a ≤ b 
Arguments: {α : Type u_1} {a b : α} [LE α]
Goal: ↑a ≤ ↑b ↔ a ≤ b
-- WithBot.some_le_some
@[simp, deprecated coe_le_coe "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem some_le_some : @LE.le (WithBot α) _ (Option.some a) (Option.some b) ↔ a ≤ b 
Arguments: {α : Type u_1} {a b : α} [LE α]
Goal: some a ≤ some b ↔ a ≤ b
-- WithBot.none_le
@[simp, deprecated bot_le "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem none_le {a : WithBot α} : @LE.le (WithBot α) _ none a 
Arguments: {α : Type u_1} [LE α] {a : WithBot α}
Goal: none ≤ a
-- WithBot.not_coe_le_bot
theorem not_coe_le_bot (a : α) : ¬(a : WithBot α) ≤ ⊥ 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: ¬↑a ≤ ⊥
-- WithBot.le_bot_iff
@[simp]
protected theorem le_bot_iff : ∀ {a : WithBot α}, a ≤ ⊥ ↔ a = ⊥
  
Arguments: {α : Type u_1} [LE α] {a : WithBot α}
Goal: a ≤ ⊥ ↔ a = ⊥
-- WithBot.coe_le
theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a ≤ b)
  
Arguments: {α : Type u_1} {a b : α} [LE α] {o : Option α}
Goal: b ∈ o → (↑a ≤ o ↔ a ≤ b)
-- WithBot.coe_le_iff
theorem coe_le_iff : ∀ {x : WithBot α}, (a : WithBot α) ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b
  
Arguments: {α : Type u_1} {a : α} [LE α] {x : WithBot α}
Goal: ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b
-- WithBot.le_coe_iff
theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a : α, x = ↑a → a ≤ b
  
Arguments: {α : Type u_1} {b : α} [LE α] {x : WithBot α}
Goal: x ≤ ↑b ↔ ∀ (a : α), x = ↑a → a ≤ b
-- IsMax.withBot
protected theorem _root_.IsMax.withBot (h : IsMax a) : IsMax (a : WithBot α)
  
Arguments: {α : Type u_1} {a : α} [LE α] (h : IsMax a)
Goal: IsMax ↑a
-- WithBot.le_unbot_iff
theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
    a ≤ unbot b h ↔ (a : WithBot α) ≤ b 
Arguments: {α : Type u_1} [LE α] {a : α} {b : WithBot α} (h : b ≠ ⊥)
Goal: a ≤ b.unbot h ↔ ↑a ≤ b
-- WithBot.unbot_le_iff
theorem unbot_le_iff {a : WithBot α} (h : a ≠ ⊥) {b : α} :
    unbot a h ≤ b ↔ a ≤ (b : WithBot α) 
Arguments: {α : Type u_1} [LE α] {a : WithBot α} (h : a ≠ ⊥) {b : α}
Goal: a.unbot h ≤ b ↔ a ≤ ↑b
-- WithBot.unbot'_le_iff
theorem unbot'_le_iff {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
    a.unbot' b ≤ c ↔ a ≤ c 
Arguments: {α : Type u_1} [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c)
Goal: WithBot.unbot' b a ≤ c ↔ a ≤ ↑c
-- WithBot.coe_lt_coe
@[simp, norm_cast]
theorem coe_lt_coe : (a : WithBot α) < b ↔ a < b 
Arguments: {α : Type u_1} {a b : α} [LT α]
Goal: ↑a < ↑b ↔ a < b
-- WithBot.bot_lt_coe
@[simp]
theorem bot_lt_coe (a : α) : ⊥ < (a : WithBot α) 
Arguments: {α : Type u_1} [LT α] (a : α)
Goal: ⊥ < ↑a
-- WithBot.not_lt_bot
@[simp]
protected theorem not_lt_bot (a : WithBot α) : ¬a < ⊥ 
Arguments: {α : Type u_1} [LT α] (a : WithBot α)
Goal: ¬a < ⊥
-- WithBot.some_lt_some
@[simp, deprecated coe_lt_coe "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem some_lt_some : @LT.lt (WithBot α) _ (Option.some a) (Option.some b) ↔ a < b 
Arguments: {α : Type u_1} {a b : α} [LT α]
Goal: some a < some b ↔ a < b
-- WithBot.none_lt_some
@[simp, deprecated bot_lt_coe "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem none_lt_some (a : α) : @LT.lt (WithBot α) _ none (some a) 
Arguments: {α : Type u_1} [LT α] (a : α)
Goal: none < ↑a
-- WithBot.not_lt_none
@[simp, deprecated not_lt_bot "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem not_lt_none (a : WithBot α) : ¬@LT.lt (WithBot α) _ a none 
Arguments: {α : Type u_1} [LT α] (a : WithBot α)
Goal: ¬a < none
-- WithBot.lt_iff_exists_coe
theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
  
Arguments: {α : Type u_1} [LT α] {a b : WithBot α}
Goal: a < b ↔ ∃ p, b = ↑p ∧ a < ↑p
-- WithBot.lt_coe_iff
theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a : α, x = a → a < b
  
Arguments: {α : Type u_1} {b : α} [LT α] {x : WithBot α}
Goal: x < ↑b ↔ ∀ (a : α), x = ↑a → a < b
-- WithBot.bot_lt_iff_ne_bot
protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
  
Arguments: {α : Type u_1} [LT α] {x : WithBot α}
Goal: ⊥ < x ↔ x ≠ ⊥
-- WithBot.unbot'_lt_iff
theorem unbot'_lt_iff {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
    a.unbot' b < c ↔ a < c 
Arguments: {α : Type u_1} [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c)
Goal: WithBot.unbot' b a < c ↔ a < ↑c
-- WithBot.coe_strictMono
theorem coe_strictMono : StrictMono (fun (a : α) => (a : WithBot α)) 
Arguments: {α : Type u_1} [Preorder α]
Goal: StrictMono fun a => ↑a
-- WithBot.coe_mono
theorem coe_mono : Monotone (fun (a : α) => (a : WithBot α)) 
Arguments: {α : Type u_1} [Preorder α]
Goal: Monotone fun a => ↑a
-- WithBot.monotone_iff
theorem monotone_iff {f : WithBot α → β} :
    Monotone f ↔ Monotone (fun a ↦ f a : α → β) ∧ ∀ x : α, f ⊥ ≤ f x 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithBot α → β}
Goal: Monotone f ↔ (Monotone fun a => f ↑a) ∧ ∀ (x : α), f ⊥ ≤ f ↑x
-- WithBot.monotone_map_iff
@[simp]
theorem monotone_map_iff {f : α → β} : Monotone (WithBot.map f) ↔ Monotone f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β}
Goal: Monotone (WithBot.map f) ↔ Monotone f
-- WithBot.strictMono_iff
theorem strictMono_iff {f : WithBot α → β} :
    StrictMono f ↔ StrictMono (fun a => f a : α → β) ∧ ∀ x : α, f ⊥ < f x 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithBot α → β}
Goal: StrictMono f ↔ (StrictMono fun a => f ↑a) ∧ ∀ (x : α), f ⊥ < f ↑x
-- WithBot.strictAnti_iff
theorem strictAnti_iff {f : WithBot α → β} :
    StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f x < f ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithBot α → β}
Goal: StrictAnti f ↔ (StrictAnti fun a => f ↑a) ∧ ∀ (x : α), f ↑x < f ⊥
-- WithBot.strictMono_map_iff
@[simp]
theorem strictMono_map_iff {f : α → β} :
    StrictMono (WithBot.map f) ↔ StrictMono f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β}
Goal: StrictMono (WithBot.map f) ↔ StrictMono f
-- WithBot.map_le_iff
theorem map_le_iff (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
    ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
  
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b) (a b : WithBot α)
Goal: WithBot.map f a ≤ WithBot.map f b ↔ a ≤ b
-- WithBot.le_coe_unbot'
theorem le_coe_unbot' : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
  
Arguments: {α : Type u_1} [Preorder α] (a : WithBot α) (b : α)
Goal: a ≤ ↑(WithBot.unbot' b a)
-- WithBot.lt_coe_bot
@[simp]
theorem lt_coe_bot [OrderBot α] : ∀ {x : WithBot α}, x < (⊥ : α) ↔ x = ⊥
  
Arguments: {α : Type u_1} [Preorder α] [OrderBot α] {x : WithBot α}
Goal: x < ↑⊥ ↔ x = ⊥
-- WithBot.coe_sup
theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = (a : WithBot α) ⊔ b 
Arguments: {α : Type u_1} [SemilatticeSup α] (a b : α)
Goal: ↑(a ⊔ b) = ↑a ⊔ ↑b
-- WithBot.coe_inf
theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithBot α) = (a : WithBot α) ⊓ b 
Arguments: {α : Type u_1} [SemilatticeInf α] (a b : α)
Goal: ↑(a ⊓ b) = ↑a ⊓ ↑b
-- WithBot.coe_min
@[simp, norm_cast]
theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min (x : WithBot α) y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: ↑(min x y) = min ↑x ↑y
-- WithBot.coe_max
@[simp, norm_cast]
theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = max (x : WithBot α) y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: ↑(max x y) = max ↑x ↑y
-- WithBot.lt_iff_exists_coe_btwn
theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α] {a b : WithBot α} :
    a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b 
Arguments: {α : Type u_1} [Preorder α] [DenselyOrdered α] [NoMinOrder α] {a b : WithBot α}
Goal: a < b ↔ ∃ x, a < ↑x ∧ ↑x < b
-- WithTop.coe_injective
theorem coe_injective : Injective ((↑) : α → WithTop α) 
Arguments: {α : Type u_1}
Goal: Function.Injective WithTop.some
-- WithTop.coe_inj
@[norm_cast]
theorem coe_inj : (a : WithTop α) = b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: ↑a = ↑b ↔ a = b
-- WithTop.forall
protected theorem «forall» {p : WithTop α → Prop} : (∀ x, p x) ↔ p ⊤ ∧ ∀ x : α, p x 
Arguments: {α : Type u_1} {p : WithTop α → Prop}
Goal: (∀ (x : WithTop α), p x) ↔ p ⊤ ∧ ∀ (x : α), p ↑x
-- WithTop.exists
protected theorem «exists» {p : WithTop α → Prop} : (∃ x, p x) ↔ p ⊤ ∨ ∃ x : α, p x 
Arguments: {α : Type u_1} {p : WithTop α → Prop}
Goal: (∃ x, p x) ↔ p ⊤ ∨ ∃ x, p ↑x
-- WithTop.none_eq_top
theorem none_eq_top : (none : WithTop α) = (⊤ : WithTop α) 
Arguments: {α : Type u_1}
Goal: none = ⊤
-- WithTop.some_eq_coe
theorem some_eq_coe (a : α) : (Option.some a : WithTop α) = (↑a : WithTop α) 
Arguments: {α : Type u_1} (a : α)
Goal: some a = ↑a
-- WithTop.top_ne_coe
@[simp]
theorem top_ne_coe : ⊤ ≠ (a : WithTop α) 
Arguments: {α : Type u_1} {a : α}
Goal: ⊤ ≠ ↑a
-- WithTop.coe_ne_top
@[simp]
theorem coe_ne_top : (a : WithTop α) ≠ ⊤ 
Arguments: {α : Type u_1} {a : α}
Goal: ↑a ≠ ⊤
-- WithTop.recTopCoe_top
@[simp]
theorem recTopCoe_top {C : WithTop α → Sort*} (d : C ⊤) (f : ∀ a : α, C a) :
    @recTopCoe _ C d f ⊤ = d 
Arguments: {α : Type u_1} {C : WithTop α → Sort u_5} (d : C ⊤) (f : (a : α) → C ↑a)
Goal: WithTop.recTopCoe d f ⊤ = d
-- WithTop.recTopCoe_coe
@[simp]
theorem recTopCoe_coe {C : WithTop α → Sort*} (d : C ⊤) (f : ∀ a : α, C a) (x : α) :
    @recTopCoe _ C d f ↑x = f x 
Arguments: {α : Type u_1} {C : WithTop α → Sort u_5} (d : C ⊤) (f : (a : α) → C ↑a) (x : α)
Goal: WithTop.recTopCoe d f ↑x = f x
-- WithTop.toDual_symm_apply
@[simp]
theorem toDual_symm_apply (a : WithBot αᵒᵈ) : WithTop.toDual.symm a = WithBot.ofDual a 
Arguments: {α : Type u_1} (a : WithBot αᵒᵈ)
Goal: WithTop.toDual.symm a = WithBot.ofDual a
-- WithTop.ofDual_symm_apply
@[simp]
theorem ofDual_symm_apply (a : WithBot α) : WithTop.ofDual.symm a = WithBot.toDual a 
Arguments: {α : Type u_1} (a : WithBot α)
Goal: WithTop.ofDual.symm a = WithBot.toDual a
-- WithTop.toDual_apply_top
@[simp]
theorem toDual_apply_top : WithTop.toDual (⊤ : WithTop α) = ⊥ 
Arguments: {α : Type u_1}
Goal: WithTop.toDual ⊤ = ⊥