ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- WithTop.ofDual_apply_top
@[simp]
theorem ofDual_apply_top : WithTop.ofDual (⊤ : WithTop α) = ⊥ 
Arguments: {α : Type u_1}
Goal: WithTop.ofDual ⊤ = ⊥
-- WithTop.toDual_apply_coe
@[simp]
theorem toDual_apply_coe (a : α) : WithTop.toDual (a : WithTop α) = toDual a 
Arguments: {α : Type u_1} (a : α)
Goal: WithTop.toDual ↑a = ↑(OrderDual.toDual a)
-- WithTop.ofDual_apply_coe
@[simp]
theorem ofDual_apply_coe (a : αᵒᵈ) : WithTop.ofDual (a : WithTop αᵒᵈ) = ofDual a 
Arguments: {α : Type u_1} (a : αᵒᵈ)
Goal: WithTop.ofDual ↑a = ↑(OrderDual.ofDual a)
-- WithTop.untop'_top
@[simp]
theorem untop'_top {α} (d : α) : untop' d ⊤ = d 
Arguments: {α : Type u_5} (d : α)
Goal: WithTop.untop' d ⊤ = d
-- WithTop.untop'_coe
@[simp]
theorem untop'_coe {α} (d x : α) : untop' d x = x 
Arguments: {α : Type u_5} (d x : α)
Goal: WithTop.untop' d ↑x = x
-- WithTop.coe_eq_coe
@[simp, norm_cast] -- Porting note: added `simp`
theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: ↑a = ↑b ↔ a = b
-- WithTop.untop'_eq_iff
theorem untop'_eq_iff {d y : α} {x : WithTop α} : untop' d x = y ↔ x = y ∨ x = ⊤ ∧ y = d 
Arguments: {α : Type u_1} {d y : α} {x : WithTop α}
Goal: WithTop.untop' d x = y ↔ x = ↑y ∨ x = ⊤ ∧ y = d
-- WithTop.untop'_eq_self_iff
@[simp] theorem untop'_eq_self_iff {d : α} {x : WithTop α} : untop' d x = d ↔ x = d ∨ x = ⊤ 
Arguments: {α : Type u_1} {d : α} {x : WithTop α}
Goal: WithTop.untop' d x = d ↔ x = ↑d ∨ x = ⊤
-- WithTop.untop'_eq_untop'_iff
theorem untop'_eq_untop'_iff {d : α} {x y : WithTop α} :
    untop' d x = untop' d y ↔ x = y ∨ x = d ∧ y = ⊤ ∨ x = ⊤ ∧ y = d 
Arguments: {α : Type u_1} {d : α} {x y : WithTop α}
Goal: WithTop.untop' d x = WithTop.untop' d y ↔ x = y ∨ x = ↑d ∧ y = ⊤ ∨ x = ⊤ ∧ y = ↑d
-- WithTop.map_top
@[simp]
theorem map_top (f : α → β) : map f ⊤ = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: WithTop.map f ⊤ = ⊤
-- WithTop.map_coe
@[simp]
theorem map_coe (f : α → β) (a : α) : map f a = f a 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : α)
Goal: WithTop.map f ↑a = ↑(f a)
-- WithTop.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: WithTop.map g₁ (WithTop.map f₁ ↑a) = WithTop.map g₂ (WithTop.map f₂ ↑a)
-- WithTop.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: WithTop.map₂ f ↑a ↑b = ↑(f a b)
-- WithTop.map₂_top_left
@[simp] lemma map₂_top_left (f : α → β → γ) (b) : map₂ f ⊤ b = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (b : WithTop β)
Goal: WithTop.map₂ f ⊤ b = ⊤
-- WithTop.map₂_top_right
@[simp] lemma map₂_top_right (f : α → β → γ) (a) : map₂ f a ⊤ = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : WithTop α)
Goal: WithTop.map₂ f a ⊤ = ⊤
-- WithTop.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 : WithTop β)
Goal: WithTop.map₂ f (↑a) b = WithTop.map (fun b => f a b) b
-- WithTop.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 : WithTop α) (b : β)
Goal: WithTop.map₂ f a ↑b = WithTop.map (fun x => f x b) a
-- WithTop.map₂_eq_top_iff
@[simp] lemma map₂_eq_top_iff {f : α → β → γ} {a : WithTop α} {b : WithTop β} :
    map₂ f a b = ⊤ ↔ a = ⊤ ∨ b = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {a : WithTop α} {b : WithTop β}
Goal: WithTop.map₂ f a b = ⊤ ↔ a = ⊤ ∨ b = ⊤
-- WithTop.map_toDual
theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
    map f (WithBot.toDual a) = a.map (toDual ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : αᵒᵈ → βᵒᵈ) (a : WithBot α)
Goal: WithTop.map f (WithBot.toDual a) = WithBot.map (⇑OrderDual.toDual ∘ f) a
-- WithTop.map_ofDual
theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDual a) = a.map (ofDual ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : WithBot αᵒᵈ)
Goal: WithTop.map f (WithBot.ofDual a) = WithBot.map (⇑OrderDual.ofDual ∘ f) a
-- WithTop.toDual_map
theorem toDual_map (f : α → β) (a : WithTop α) :
    WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) (WithTop.toDual a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : WithTop α)
Goal: WithTop.toDual (WithTop.map f a) = WithBot.map (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) (WithTop.toDual a)
-- WithTop.ofDual_map
theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ) :
    WithTop.ofDual (map f a) = WithBot.map (ofDual ∘ f ∘ toDual) (WithTop.ofDual a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ)
Goal: WithTop.ofDual (WithTop.map f a) = WithBot.map (⇑OrderDual.ofDual ∘ f ∘ ⇑OrderDual.toDual) (WithTop.ofDual a)
-- WithTop.ne_top_iff_exists
lemma ne_top_iff_exists {x : WithTop α} : x ≠ ⊤ ↔ ∃ a : α, ↑a = x 
Arguments: {α : Type u_1} {x : WithTop α}
Goal: x ≠ ⊤ ↔ ∃ a, ↑a = x
-- WithTop.forall_ne_iff_eq_top
lemma forall_ne_iff_eq_top {x : WithTop α} : (∀ a : α, ↑a ≠ x) ↔ x = ⊤ 
Arguments: {α : Type u_1} {x : WithTop α}
Goal: (∀ (a : α), ↑a ≠ x) ↔ x = ⊤
-- WithTop.coe_untop
@[simp] lemma coe_untop : ∀ (x : WithTop α) hx, x.untop hx = x 
Arguments: {α : Type u_1} (x : WithTop α) (hx : x ≠ ⊤)
Goal: ↑(x.untop hx) = x
-- WithTop.untop_coe
@[simp]
theorem untop_coe (x : α) (h : (x : WithTop α) ≠ ⊤ := coe_ne_top) : (x : WithTop α).untop h = x 
Arguments: {α : Type u_1} (x : α) (h : ↑x ≠ ⊤ := ⋯)
Goal: (↑x).untop h = x
-- WithTop.coe_bot
@[simp, norm_cast] lemma coe_bot [Bot α] : ((⊥ : α) : WithTop α) = ⊥ 
Arguments: {α : Type u_1} [Bot α]
Goal: ↑⊥ = ⊥
-- WithTop.coe_eq_bot
@[simp, norm_cast] lemma coe_eq_bot [Bot α] {a : α} : (a : WithTop α) = ⊥ ↔ a = ⊥ 
Arguments: {α : Type u_1} [Bot α] {a : α}
Goal: ↑a = ⊥ ↔ a = ⊥
-- WithTop.bot_eq_coe
@[simp, norm_cast] lemma bot_eq_coe [Bot α] {a : α} : (⊥ : WithTop α) = a ↔ ⊥ = a 
Arguments: {α : Type u_1} [Bot α] {a : α}
Goal: ⊥ = ↑a ↔ ⊥ = a
-- WithTop.toDual_le_iff
theorem toDual_le_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
    WithTop.toDual a ≤ b ↔ WithBot.ofDual b ≤ a 
Arguments: {α : Type u_1} [LE α] {a : WithTop α} {b : WithBot αᵒᵈ}
Goal: WithTop.toDual a ≤ b ↔ WithBot.ofDual b ≤ a
-- WithTop.le_toDual_iff
theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a 
Arguments: {α : Type u_1} [LE α] {a : WithBot αᵒᵈ} {b : WithTop α}
Goal: a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a
-- WithTop.toDual_le_toDual_iff
@[simp]
theorem toDual_le_toDual_iff {a b : WithTop α} : WithTop.toDual a ≤ WithTop.toDual b ↔ b ≤ a 
Arguments: {α : Type u_1} [LE α] {a b : WithTop α}
Goal: WithTop.toDual a ≤ WithTop.toDual b ↔ b ≤ a
-- WithTop.ofDual_le_iff
theorem ofDual_le_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
    WithTop.ofDual a ≤ b ↔ WithBot.toDual b ≤ a 
Arguments: {α : Type u_1} [LE α] {a : WithTop αᵒᵈ} {b : WithBot α}
Goal: WithTop.ofDual a ≤ b ↔ WithBot.toDual b ≤ a
-- WithTop.le_ofDual_iff
theorem le_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
    a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a 
Arguments: {α : Type u_1} [LE α] {a : WithBot α} {b : WithTop αᵒᵈ}
Goal: a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a
-- WithTop.ofDual_le_ofDual_iff
@[simp]
theorem ofDual_le_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a ≤ WithTop.ofDual b ↔ b ≤ a 
Arguments: {α : Type u_1} [LE α] {a b : WithTop αᵒᵈ}
Goal: WithTop.ofDual a ≤ WithTop.ofDual b ↔ b ≤ a
-- WithTop.coe_le_coe
@[simp, norm_cast]
theorem coe_le_coe : (a : WithTop α) ≤ b ↔ a ≤ b 
Arguments: {α : Type u_1} {a b : α} [LE α]
Goal: ↑a ≤ ↑b ↔ a ≤ b
-- WithTop.some_le_some
@[simp, deprecated coe_le_coe "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem some_le_some : @LE.le (WithTop α) _ (Option.some a) (Option.some b) ↔ a ≤ b 
Arguments: {α : Type u_1} {a b : α} [LE α]
Goal: some a ≤ some b ↔ a ≤ b
-- WithTop.le_none
@[simp, deprecated le_top "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem le_none {a : WithTop α} : @LE.le (WithTop α) _ a none 
Arguments: {α : Type u_1} [LE α] {a : WithTop α}
Goal: a ≤ none
-- WithTop.not_top_le_coe
theorem not_top_le_coe (a : α) : ¬(⊤ : WithTop α) ≤ ↑a 
Arguments: {α : Type u_1} [LE α] (a : α)
Goal: ¬⊤ ≤ ↑a
-- WithTop.top_le_iff
@[simp]
protected theorem top_le_iff : ∀ {a : WithTop α}, ⊤ ≤ a ↔ a = ⊤
  
Arguments: {α : Type u_1} [LE α] {a : WithTop α}
Goal: ⊤ ≤ a ↔ a = ⊤
-- WithTop.le_coe
theorem le_coe : ∀ {o : Option α}, a ∈ o → (@LE.le (WithTop α) _ o b ↔ a ≤ b)
  
Arguments: {α : Type u_1} {a b : α} [LE α] {o : Option α}
Goal: a ∈ o → (o ≤ ↑b ↔ a ≤ b)
-- WithTop.le_coe_iff
theorem le_coe_iff {x : WithTop α} : x ≤ b ↔ ∃ a : α, x = a ∧ a ≤ b 
Arguments: {α : Type u_1} {b : α} [LE α] {x : WithTop α}
Goal: x ≤ ↑b ↔ ∃ a, x = ↑a ∧ a ≤ b
-- WithTop.coe_le_iff
theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b : α, x = ↑b → a ≤ b 
Arguments: {α : Type u_1} {a : α} [LE α] {x : WithTop α}
Goal: ↑a ≤ x ↔ ∀ (b : α), x = ↑b → a ≤ b
-- IsMin.withTop
protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) 
Arguments: {α : Type u_1} {a : α} [LE α] (h : IsMin a)
Goal: IsMin ↑a
-- WithTop.untop_le_iff
theorem untop_le_iff {a : WithTop α} {b : α} (h : a ≠ ⊤) :
    untop a h ≤ b ↔ a ≤ (b : WithTop α) 
Arguments: {α : Type u_1} [LE α] {a : WithTop α} {b : α} (h : a ≠ ⊤)
Goal: a.untop h ≤ b ↔ a ≤ ↑b
-- WithTop.le_untop_iff
theorem le_untop_iff {a : α} {b : WithTop α} (h : b ≠ ⊤) :
    a ≤ untop b h ↔ (a : WithTop α) ≤ b 
Arguments: {α : Type u_1} [LE α] {a : α} {b : WithTop α} (h : b ≠ ⊤)
Goal: a ≤ b.untop h ↔ ↑a ≤ b
-- WithTop.le_untop'_iff
theorem le_untop'_iff {a : WithTop α} {b c : α} (h : a = ⊤ → c ≤ b) :
    c ≤ a.untop' b ↔ c ≤ a 
Arguments: {α : Type u_1} [LE α] {a : WithTop α} {b c : α} (h : a = ⊤ → c ≤ b)
Goal: c ≤ WithTop.untop' b a ↔ ↑c ≤ a
-- WithTop.toDual_lt_iff
theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
    WithTop.toDual a < b ↔ WithBot.ofDual b < a 
Arguments: {α : Type u_1} [LT α] {a : WithTop α} {b : WithBot αᵒᵈ}
Goal: WithTop.toDual a < b ↔ WithBot.ofDual b < a
-- WithTop.lt_toDual_iff
theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    a < WithTop.toDual b ↔ b < WithBot.ofDual a 
Arguments: {α : Type u_1} [LT α] {a : WithBot αᵒᵈ} {b : WithTop α}
Goal: a < WithTop.toDual b ↔ b < WithBot.ofDual a
-- WithTop.toDual_lt_toDual_iff
@[simp]
theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toDual b ↔ b < a 
Arguments: {α : Type u_1} [LT α] {a b : WithTop α}
Goal: WithTop.toDual a < WithTop.toDual b ↔ b < a
-- WithTop.ofDual_lt_iff
theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
    WithTop.ofDual a < b ↔ WithBot.toDual b < a 
Arguments: {α : Type u_1} [LT α] {a : WithTop αᵒᵈ} {b : WithBot α}
Goal: WithTop.ofDual a < b ↔ WithBot.toDual b < a
-- WithTop.lt_ofDual_iff
theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
    a < WithTop.ofDual b ↔ b < WithBot.toDual a 
Arguments: {α : Type u_1} [LT α] {a : WithBot α} {b : WithTop αᵒᵈ}
Goal: a < WithTop.ofDual b ↔ b < WithBot.toDual a
-- WithTop.ofDual_lt_ofDual_iff
@[simp]
theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a 
Arguments: {α : Type u_1} [LT α] {a b : WithTop αᵒᵈ}
Goal: WithTop.ofDual a < WithTop.ofDual b ↔ b < a
-- WithTop.lt_untop'_iff
theorem lt_untop'_iff {a : WithTop α} {b c : α} (h : a = ⊤ → c < b) :
    c < a.untop' b ↔ c < a 
Arguments: {α : Type u_1} [LT α] {a : WithTop α} {b c : α} (h : a = ⊤ → c < b)
Goal: c < WithTop.untop' b a ↔ ↑c < a
-- WithBot.toDual_symm_apply
@[simp]
theorem toDual_symm_apply (a : WithTop αᵒᵈ) : WithBot.toDual.symm a = WithTop.ofDual a 
Arguments: {α : Type u_1} (a : WithTop αᵒᵈ)
Goal: WithBot.toDual.symm a = WithTop.ofDual a
-- WithBot.ofDual_symm_apply
@[simp]
theorem ofDual_symm_apply (a : WithTop α) : WithBot.ofDual.symm a = WithTop.toDual a 
Arguments: {α : Type u_1} (a : WithTop α)
Goal: WithBot.ofDual.symm a = WithTop.toDual a
-- WithBot.toDual_apply_bot
@[simp]
theorem toDual_apply_bot : WithBot.toDual (⊥ : WithBot α) = ⊤ 
Arguments: {α : Type u_1}
Goal: WithBot.toDual ⊥ = ⊤
-- WithBot.ofDual_apply_bot
@[simp]
theorem ofDual_apply_bot : WithBot.ofDual (⊥ : WithBot α) = ⊤ 
Arguments: {α : Type u_1}
Goal: WithBot.ofDual ⊥ = ⊤
-- WithBot.toDual_apply_coe
@[simp]
theorem toDual_apply_coe (a : α) : WithBot.toDual (a : WithBot α) = toDual a 
Arguments: {α : Type u_1} (a : α)
Goal: WithBot.toDual ↑a = ↑(OrderDual.toDual a)
-- WithBot.ofDual_apply_coe
@[simp]
theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ) = ofDual a 
Arguments: {α : Type u_1} (a : αᵒᵈ)
Goal: WithBot.ofDual ↑a = ↑(OrderDual.ofDual a)
-- WithBot.map_toDual
theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
    WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : αᵒᵈ → βᵒᵈ) (a : WithTop α)
Goal: WithBot.map f (WithTop.toDual a) = WithTop.map (⇑OrderDual.toDual ∘ f) a
-- WithBot.map_ofDual
theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
    WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : WithTop αᵒᵈ)
Goal: WithBot.map f (WithTop.ofDual a) = WithTop.map (⇑OrderDual.ofDual ∘ f) a
-- WithBot.toDual_map
theorem toDual_map (f : α → β) (a : WithBot α) :
    WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) (WithBot.toDual a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : WithBot α)
Goal: WithBot.toDual (WithBot.map f a) = WithBot.map (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) (WithBot.toDual a)
-- WithBot.ofDual_map
theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
    WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) (WithBot.ofDual a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ)
Goal: WithBot.ofDual (WithBot.map f a) = WithBot.map (⇑OrderDual.ofDual ∘ f ∘ ⇑OrderDual.toDual) (WithBot.ofDual a)
-- WithBot.forall_lt_iff_eq_bot
lemma forall_lt_iff_eq_bot [Preorder α] {x : WithBot α} :
    (∀ y : α, x < y) ↔ x = ⊥ 
Arguments: {α : Type u_1} [Preorder α] {x : WithBot α}
Goal: (∀ (y : α), x < ↑y) ↔ x = ⊥
-- WithBot.toDual_le_iff
theorem toDual_le_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
    WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a 
Arguments: {α : Type u_1} [LE α] {a : WithBot α} {b : WithTop αᵒᵈ}
Goal: WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a
-- WithBot.le_toDual_iff
theorem le_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
    a ≤ WithBot.toDual b ↔ b ≤ WithTop.ofDual a 
Arguments: {α : Type u_1} [LE α] {a : WithTop αᵒᵈ} {b : WithBot α}
Goal: a ≤ WithBot.toDual b ↔ b ≤ WithTop.ofDual a
-- WithBot.toDual_le_toDual_iff
@[simp]
theorem toDual_le_toDual_iff {a b : WithBot α} : WithBot.toDual a ≤ WithBot.toDual b ↔ b ≤ a 
Arguments: {α : Type u_1} [LE α] {a b : WithBot α}
Goal: WithBot.toDual a ≤ WithBot.toDual b ↔ b ≤ a
-- WithBot.ofDual_le_iff
theorem ofDual_le_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a 
Arguments: {α : Type u_1} [LE α] {a : WithBot αᵒᵈ} {b : WithTop α}
Goal: WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a
-- WithBot.le_ofDual_iff
theorem le_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
    a ≤ WithBot.ofDual b ↔ b ≤ WithTop.toDual a 
Arguments: {α : Type u_1} [LE α] {a : WithTop α} {b : WithBot αᵒᵈ}
Goal: a ≤ WithBot.ofDual b ↔ b ≤ WithTop.toDual a
-- WithBot.ofDual_le_ofDual_iff
@[simp]
theorem ofDual_le_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a ≤ WithBot.ofDual b ↔ b ≤ a 
Arguments: {α : Type u_1} [LE α] {a b : WithBot αᵒᵈ}
Goal: WithBot.ofDual a ≤ WithBot.ofDual b ↔ b ≤ a
-- WithBot.toDual_lt_iff
theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
    WithBot.toDual a < b ↔ WithTop.ofDual b < a 
Arguments: {α : Type u_1} [LT α] {a : WithBot α} {b : WithTop αᵒᵈ}
Goal: WithBot.toDual a < b ↔ WithTop.ofDual b < a
-- WithBot.lt_toDual_iff
theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
    a < WithBot.toDual b ↔ b < WithTop.ofDual a 
Arguments: {α : Type u_1} [LT α] {a : WithTop αᵒᵈ} {b : WithBot α}
Goal: a < WithBot.toDual b ↔ b < WithTop.ofDual a
-- WithBot.toDual_lt_toDual_iff
@[simp]
theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toDual b ↔ b < a 
Arguments: {α : Type u_1} [LT α] {a b : WithBot α}
Goal: WithBot.toDual a < WithBot.toDual b ↔ b < a
-- WithBot.ofDual_lt_iff
theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    WithBot.ofDual a < b ↔ WithTop.toDual b < a 
Arguments: {α : Type u_1} [LT α] {a : WithBot αᵒᵈ} {b : WithTop α}
Goal: WithBot.ofDual a < b ↔ WithTop.toDual b < a
-- WithBot.lt_ofDual_iff
theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
    a < WithBot.ofDual b ↔ b < WithTop.toDual a 
Arguments: {α : Type u_1} [LT α] {a : WithTop α} {b : WithBot αᵒᵈ}
Goal: a < WithBot.ofDual b ↔ b < WithTop.toDual a
-- WithBot.ofDual_lt_ofDual_iff
@[simp]
theorem ofDual_lt_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a < WithBot.ofDual b ↔ b < a 
Arguments: {α : Type u_1} [LT α] {a b : WithBot αᵒᵈ}
Goal: WithBot.ofDual a < WithBot.ofDual b ↔ b < a
-- WithTop.coe_lt_coe
@[simp, norm_cast]
theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b 
Arguments: {α : Type u_1} [LT α] {a b : α}
Goal: ↑a < ↑b ↔ a < b
-- WithTop.coe_lt_top
@[simp]
theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ 
Arguments: {α : Type u_1} [LT α] (a : α)
Goal: ↑a < ⊤
-- WithTop.not_top_lt
@[simp]
protected theorem not_top_lt (a : WithTop α) : ¬⊤ < a 
Arguments: {α : Type u_1} [LT α] (a : WithTop α)
Goal: ¬⊤ < a
-- WithTop.some_lt_some
@[simp, deprecated coe_lt_coe "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem some_lt_some : @LT.lt (WithTop α) _ (Option.some a) (Option.some b) ↔ a < b 
Arguments: {α : Type u_1} [LT α] {a b : α}
Goal: some a < some b ↔ a < b
-- WithTop.some_lt_none
@[simp, deprecated coe_lt_top "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem some_lt_none (a : α) : @LT.lt (WithTop α) _ (Option.some a) none 
Arguments: {α : Type u_1} [LT α] (a : α)
Goal: some a < none
-- WithTop.not_none_lt
@[simp, deprecated not_top_lt "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a 
Arguments: {α : Type u_1} [LT α] (a : WithTop α)
Goal: ¬none < a
-- WithTop.lt_iff_exists_coe
theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ ↑p < b 
Arguments: {α : Type u_1} [LT α] {a b : WithTop α}
Goal: a < b ↔ ∃ p, a = ↑p ∧ ↑p < b
-- WithTop.coe_lt_iff
theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b : α, x = ↑b → a < b 
Arguments: {α : Type u_1} [LT α] {a : α} {x : WithTop α}
Goal: ↑a < x ↔ ∀ (b : α), x = ↑b → a < b
-- WithTop.lt_top_iff_ne_top
protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ 
Arguments: {α : Type u_1} [LT α] {x : WithTop α}
Goal: x < ⊤ ↔ x ≠ ⊤
-- WithTop.coe_strictMono
theorem coe_strictMono : StrictMono (fun a : α => (a : WithTop α)) 
Arguments: {α : Type u_1} [Preorder α]
Goal: StrictMono fun a => ↑a
-- WithTop.coe_mono
theorem coe_mono : Monotone (fun a : α => (a : WithTop α)) 
Arguments: {α : Type u_1} [Preorder α]
Goal: Monotone fun a => ↑a
-- WithTop.monotone_iff
theorem monotone_iff {f : WithTop α → β} :
    Monotone f ↔ Monotone (fun (a : α) => f a) ∧ ∀ x : α, f x ≤ f ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithTop α → β}
Goal: Monotone f ↔ (Monotone fun a => f ↑a) ∧ ∀ (x : α), f ↑x ≤ f ⊤
-- WithTop.monotone_map_iff
@[simp]
theorem monotone_map_iff {f : α → β} : Monotone (WithTop.map f) ↔ Monotone f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β}
Goal: Monotone (WithTop.map f) ↔ Monotone f
-- WithTop.strictMono_iff
theorem strictMono_iff {f : WithTop α → β} :
    StrictMono f ↔ StrictMono (fun (a : α) => f a) ∧ ∀ x : α, f x < f ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithTop α → β}
Goal: StrictMono f ↔ (StrictMono fun a => f ↑a) ∧ ∀ (x : α), f ↑x < f ⊤
-- WithTop.strictAnti_iff
theorem strictAnti_iff {f : WithTop α → β} :
    StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f ⊤ < f x 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : WithTop α → β}
Goal: StrictAnti f ↔ (StrictAnti fun a => f ↑a) ∧ ∀ (x : α), f ⊤ < f ↑x
-- WithTop.strictMono_map_iff
@[simp]
theorem strictMono_map_iff {f : α → β} : StrictMono (WithTop.map f) ↔ StrictMono f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β}
Goal: StrictMono (WithTop.map f) ↔ StrictMono f
-- WithTop.map_le_iff
theorem map_le_iff (f : α → β) (a b : WithTop α)
    (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
    a.map f ≤ b.map f ↔ a ≤ b 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α) (mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b)
Goal: WithTop.map f a ≤ WithTop.map f b ↔ a ≤ b
-- WithTop.coe_untop'_le
theorem coe_untop'_le (a : WithTop α) (b : α) : a.untop' b ≤ a 
Arguments: {α : Type u_1} [Preorder α] (a : WithTop α) (b : α)
Goal: ↑(WithTop.untop' b a) ≤ a
-- WithTop.coe_top_lt
@[simp]
theorem coe_top_lt [OrderTop α] {x : WithTop α} : (⊤ : α) < x ↔ x = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [OrderTop α] {x : WithTop α}
Goal: ↑⊤ < x ↔ x = ⊤
-- WithTop.forall_lt_iff_eq_top
lemma forall_lt_iff_eq_top {x : WithTop α} : (∀ y : α, y < x) ↔ x = ⊤ 
Arguments: {α : Type u_1} [Preorder α] {x : WithTop α}
Goal: (∀ (y : α), ↑y < x) ↔ x = ⊤
-- WithTop.coe_inf
theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = (a : WithTop α) ⊓ b 
Arguments: {α : Type u_1} [SemilatticeInf α] (a b : α)
Goal: ↑(a ⊓ b) = ↑a ⊓ ↑b
-- WithTop.coe_sup
theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = (a : WithTop α) ⊔ b 
Arguments: {α : Type u_1} [SemilatticeSup α] (a b : α)
Goal: ↑(a ⊔ b) = ↑a ⊔ ↑b
-- WithTop.coe_min
@[simp, norm_cast]
theorem coe_min [LinearOrder α] (x y : α) : (↑(min x y) : WithTop α) = min (x : WithTop α) y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: ↑(min x y) = min ↑x ↑y
-- WithTop.coe_max
@[simp, norm_cast]
theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max (x : WithTop α) y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: ↑(max x y) = max ↑x ↑y
-- WithTop.lt_iff_exists_coe_btwn
theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
    a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b 
Arguments: {α : Type u_1} [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α}
Goal: a < b ↔ ∃ x, a < ↑x ∧ ↑x < b
-- dvd_sub_pow_of_dvd_sub
theorem dvd_sub_pow_of_dvd_sub {R : Type*} [CommRing R] {p : ℕ} {a b : R} (h : (p : R) ∣ a - b)
    (k : ℕ) : (p ^ (k + 1) : R) ∣ a ^ p ^ k - b ^ p ^ k 
Arguments: {R : Type u_1} [CommRing R] {p : ℕ} {a b : R} (h : ↑p ∣ a - b) (k : ℕ)
Goal: ↑p ^ (k + 1) ∣ a ^ p ^ k - b ^ p ^ k
-- DirichletCharacter.unit_norm_eq_one
@[simp] lemma unit_norm_eq_one (a : (ZMod n)ˣ) : ‖χ a‖ = 1 
Arguments: {F : Type u_1} [NormedField F] {n : ℕ} (χ : DirichletCharacter F n) (a : (ZMod n)ˣ)
Goal: ‖χ ↑a‖ = 1
-- DirichletCharacter.norm_le_one
lemma norm_le_one (a : ZMod n) : ‖χ a‖ ≤ 1 
Arguments: {F : Type u_1} [NormedField F] {n : ℕ} (χ : DirichletCharacter F n) (a : ZMod n)
Goal: ‖χ a‖ ≤ 1
-- isUpperSet_empty
theorem isUpperSet_empty : IsUpperSet (∅ : Set α) 
Arguments: {α : Type u_1} [LE α]
Goal: IsUpperSet ∅
-- isLowerSet_empty
theorem isLowerSet_empty : IsLowerSet (∅ : Set α) 
Arguments: {α : Type u_1} [LE α]
Goal: IsLowerSet ∅
-- isUpperSet_univ
theorem isUpperSet_univ : IsUpperSet (univ : Set α) 
Arguments: {α : Type u_1} [LE α]
Goal: IsUpperSet Set.univ
-- isLowerSet_univ
theorem isLowerSet_univ : IsLowerSet (univ : Set α) 
Arguments: {α : Type u_1} [LE α]
Goal: IsLowerSet Set.univ
-- IsUpperSet.compl
theorem IsUpperSet.compl (hs : IsUpperSet s) : IsLowerSet sᶜ 
Arguments: {α : Type u_1} [LE α] {s : Set α} (hs : IsUpperSet s)
Goal: IsLowerSet sᶜ
-- IsLowerSet.compl
theorem IsLowerSet.compl (hs : IsLowerSet s) : IsUpperSet sᶜ 
Arguments: {α : Type u_1} [LE α] {s : Set α} (hs : IsLowerSet s)
Goal: IsUpperSet sᶜ