ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.card_fintypeIoc
theorem card_fintypeIoc : Fintype.card (Set.Ioc a b) = b - a 
Arguments: (a b : ℕ)
Goal: Fintype.card ↑(Set.Ioc a b) = b - a
-- Nat.card_fintypeIoo
theorem card_fintypeIoo : Fintype.card (Set.Ioo a b) = b - a - 1 
Arguments: (a b : ℕ)
Goal: Fintype.card ↑(Set.Ioo a b) = b - a - 1
-- Nat.card_fintypeIic
theorem card_fintypeIic : Fintype.card (Set.Iic b) = b + 1 
Arguments: (b : ℕ)
Goal: Fintype.card ↑(Set.Iic b) = b + 1
-- Nat.card_fintypeIio
theorem card_fintypeIio : Fintype.card (Set.Iio b) = b 
Arguments: (b : ℕ)
Goal: Fintype.card ↑(Set.Iio b) = b
-- Nat.Icc_succ_left
theorem Icc_succ_left : Icc a.succ b = Ioc a b 
Arguments: (a b : ℕ)
Goal: Finset.Icc a.succ b = Finset.Ioc a b
-- Nat.Ico_succ_right
theorem Ico_succ_right : Ico a b.succ = Icc a b 
Arguments: (a b : ℕ)
Goal: Finset.Ico a b.succ = Finset.Icc a b
-- Nat.Ico_succ_left
theorem Ico_succ_left : Ico a.succ b = Ioo a b 
Arguments: (a b : ℕ)
Goal: Finset.Ico a.succ b = Finset.Ioo a b
-- Nat.Icc_pred_right
theorem Icc_pred_right {b : ℕ} (h : 0 < b) : Icc a (b - 1) = Ico a b 
Arguments: (a : ℕ) {b : ℕ} (h : 0 < b)
Goal: Finset.Icc a (b - 1) = Finset.Ico a b
-- Nat.Ico_succ_succ
theorem Ico_succ_succ : Ico a.succ b.succ = Ioc a b 
Arguments: (a b : ℕ)
Goal: Finset.Ico a.succ b.succ = Finset.Ioc a b
-- Nat.Ico_succ_singleton
@[simp]
theorem Ico_succ_singleton : Ico a (a + 1) = {a} 
Arguments: (a : ℕ)
Goal: Finset.Ico a (a + 1) = {a}
-- Nat.Ico_pred_singleton
@[simp]
theorem Ico_pred_singleton {a : ℕ} (h : 0 < a) : Ico (a - 1) a = {a - 1} 
Arguments: {a : ℕ} (h : 0 < a)
Goal: Finset.Ico (a - 1) a = {a - 1}
-- Nat.Ioc_succ_singleton
@[simp]
theorem Ioc_succ_singleton : Ioc b (b + 1) = {b + 1} 
Arguments: (b : ℕ)
Goal: Finset.Ioc b (b + 1) = {b + 1}
-- Nat.Ico_succ_right_eq_insert_Ico
theorem Ico_succ_right_eq_insert_Ico (h : a ≤ b) : Ico a (b + 1) = insert b (Ico a b) 
Arguments: {a b : ℕ} (h : a ≤ b)
Goal: Finset.Ico a (b + 1) = insert b (Finset.Ico a b)
-- Nat.Ico_insert_succ_left
theorem Ico_insert_succ_left (h : a < b) : insert a (Ico a.succ b) = Ico a b 
Arguments: {a b : ℕ} (h : a < b)
Goal: insert a (Finset.Ico a.succ b) = Finset.Ico a b
-- Nat.Icc_insert_succ_left
lemma Icc_insert_succ_left (h : a ≤ b) : insert a (Icc (a + 1) b) = Icc a b 
Arguments: {a b : ℕ} (h : a ≤ b)
Goal: insert a (Finset.Icc (a + 1) b) = Finset.Icc a b
-- Nat.Icc_insert_succ_right
lemma Icc_insert_succ_right (h : a ≤ b + 1) : insert (b + 1) (Icc a b) = Icc a (b + 1) 
Arguments: {a b : ℕ} (h : a ≤ b + 1)
Goal: insert (b + 1) (Finset.Icc a b) = Finset.Icc a (b + 1)
-- Nat.image_sub_const_Ico
theorem image_sub_const_Ico (h : c ≤ a) :
    ((Ico a b).image fun x => x - c) = Ico (a - c) (b - c) 
Arguments: {a b c : ℕ} (h : c ≤ a)
Goal: Finset.image (fun x => x - c) (Finset.Ico a b) = Finset.Ico (a - c) (b - c)
-- Nat.Ico_image_const_sub_eq_Ico
theorem Ico_image_const_sub_eq_Ico (hac : a ≤ c) :
    ((Ico a b).image fun x => c - x) = Ico (c + 1 - b) (c + 1 - a) 
Arguments: {a b c : ℕ} (hac : a ≤ c)
Goal: Finset.image (fun x => c - x) (Finset.Ico a b) = Finset.Ico (c + 1 - b) (c + 1 - a)
-- Nat.Ico_succ_left_eq_erase_Ico
theorem Ico_succ_left_eq_erase_Ico : Ico a.succ b = erase (Ico a b) a 
Arguments: {a b : ℕ}
Goal: Finset.Ico a.succ b = (Finset.Ico a b).erase a
-- Nat.mod_injOn_Ico
theorem mod_injOn_Ico (n a : ℕ) : Set.InjOn (· % a) (Finset.Ico n (n + a)) 
Arguments: (n a : ℕ)
Goal: Set.InjOn (fun x => x % a) ↑(Finset.Ico n (n + a))
-- Nat.image_Ico_mod
theorem image_Ico_mod (n a : ℕ) : (Ico n (n + a)).image (· % a) = range a 
Arguments: (n a : ℕ)
Goal: Finset.image (fun x => x % a) (Finset.Ico n (n + a)) = Finset.range a
-- Nat.multiset_Ico_map_mod
theorem multiset_Ico_map_mod (n a : ℕ) :
    (Multiset.Ico n (n + a)).map (· % a) = Multiset.range a 
Arguments: (n a : ℕ)
Goal: Multiset.map (fun x => x % a) (Multiset.Ico n (n + a)) = Multiset.range a
-- Finset.range_image_pred_top_sub
theorem range_image_pred_top_sub (n : ℕ) :
    ((Finset.range n).image fun j => n - 1 - j) = Finset.range n 
Arguments: (n : ℕ)
Goal: Finset.image (fun j => n - 1 - j) (Finset.range n) = Finset.range n
-- Finset.range_add_eq_union
theorem range_add_eq_union : range (a + b) = range a ∪ (range b).map (addLeftEmbedding a) 
Arguments: (a b : ℕ)
Goal: Finset.range (a + b) = Finset.range a ∪ Finset.map (addLeftEmbedding a) (Finset.range b)
-- Nat.decreasing_induction_of_not_bddAbove
theorem Nat.decreasing_induction_of_not_bddAbove (hP : ¬BddAbove { x | P x }) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (h : ∀ (n : ℕ), P (n + 1) → P n) (hP : ¬BddAbove {x | P x}) (n : ℕ)
Goal: P n
-- Nat.strong_decreasing_induction
@[elab_as_elim]
lemma Nat.strong_decreasing_induction (base : ∃ n, ∀ m > n, P m) (step : ∀ n, (∀ m > n, P m) → P n)
    (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (base : ∃ n, ∀ m > n, P m) (step : ∀ (n : ℕ), (∀ m > n, P m) → P n) (n : ℕ)
Goal: P n
-- Nat.decreasing_induction_of_infinite
theorem Nat.decreasing_induction_of_infinite (hP : { x | P x }.Infinite) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (h : ∀ (n : ℕ), P (n + 1) → P n) (hP : {x | P x}.Infinite) (n : ℕ)
Goal: P n
-- Nat.cauchy_induction'
theorem Nat.cauchy_induction' (seed : ℕ) (h : ∀ n, P (n + 1) → P n) (hs : P seed)
    (hi : ∀ x, seed ≤ x → P x → ∃ y, x < y ∧ P y) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (seed : ℕ) (h : ∀ (n : ℕ), P (n + 1) → P n) (hs : P seed) (hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y) (n : ℕ)
Goal: P n
-- Nat.cauchy_induction
theorem Nat.cauchy_induction (seed : ℕ) (hs : P seed) (f : ℕ → ℕ)
    (hf : ∀ x, seed ≤ x → P x → x < f x ∧ P (f x)) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (h : ∀ (n : ℕ), P (n + 1) → P n) (seed : ℕ) (hs : P seed) (f : ℕ → ℕ) (hf : ∀ (x : ℕ), seed ≤ x → P x → x < f x ∧ P (f x)) (n : ℕ)
Goal: P n
-- Nat.cauchy_induction_mul
theorem Nat.cauchy_induction_mul (h : ∀ (n : ℕ), P (n + 1) → P n) (k seed : ℕ) (hk : 1 < k)
    (hs : P seed.succ) (hm : ∀ x, seed < x → P x → P (k * x)) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (h : ∀ (n : ℕ), P (n + 1) → P n) (k seed : ℕ) (hk : 1 < k) (hs : P seed.succ) (hm : ∀ (x : ℕ), seed < x → P x → P (k * x)) (n : ℕ)
Goal: P n
-- Nat.cauchy_induction_two_mul
theorem Nat.cauchy_induction_two_mul (seed : ℕ) (hs : P seed.succ)
    (hm : ∀ x, seed < x → P x → P (2 * x)) (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (h : ∀ (n : ℕ), P (n + 1) → P n) (seed : ℕ) (hs : P seed.succ) (hm : ∀ (x : ℕ), seed < x → P x → P (2 * x)) (n : ℕ)
Goal: P n
-- Nat.pow_imp_self_of_one_lt
theorem Nat.pow_imp_self_of_one_lt {M} [Monoid M] (k : ℕ) (hk : 1 < k)
    (P : M → Prop) (hmul : ∀ x y, P x → P (x * y) ∨ P (y * x))
    (hpow : ∀ x, P (x ^ k) → P x) : ∀ n x, P (x ^ n) → P x 
Arguments: {M : Type u_1} [Monoid M] (k : ℕ) (hk : 1 < k) (P : M → Prop) (hmul : ∀ (x y : M), P x → P (x * y) ∨ P (y * x)) (hpow : ∀ (x : M), P (x ^ k) → P x) (n : ℕ) (x : M)
Goal: P (x ^ n) → P x
-- CircularPreorder.btw_cyclic_left
class CircularPreorder (α : Type*) extends Btw α, SBtw α where
    btw_refl (a : α) : btw a a a
    btw_cyclic_left {a b c : α} : btw a b c → btw b c a
  sbtw := fun a b c => btw a b c ∧ ¬btw c b a
    sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a := by intros; rfl
    sbtw_trans_left {a b c d : α} : sbtw a b c → sbtw b d c → sbtw a d c
Arguments: {α : Type u_1} [self : CircularPreorder α] {a b c : α}
Goal: btw a b c → btw b c a
-- CircularPreorder.sbtw_iff_btw_not_btw
class CircularPreorder (α : Type*) extends Btw α, SBtw α where
    btw_refl (a : α) : btw a a a
    btw_cyclic_left {a b c : α} : btw a b c → btw b c a
  sbtw := fun a b c => btw a b c ∧ ¬btw c b a
    sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a := by intros; rfl
    sbtw_trans_left {a b c d : α} : sbtw a b c → sbtw b d c → sbtw a d c
Arguments: {α : Type u_1} [self : CircularPreorder α] {a b c : α}
Goal: sbtw a b c ↔ btw a b c ∧ ¬btw c b a
-- CircularPreorder.btw_refl
class CircularPreorder (α : Type*) extends Btw α, SBtw α where
    btw_refl (a : α) : btw a a a
    btw_cyclic_left {a b c : α} : btw a b c → btw b c a
  sbtw := fun a b c => btw a b c ∧ ¬btw c b a
    sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a := by intros; rfl
    sbtw_trans_left {a b c d : α} : sbtw a b c → sbtw b d c → sbtw a d c
Arguments: {α : Type u_1} [self : CircularPreorder α] (a : α)
Goal: btw a a a
-- CircularPreorder.sbtw_trans_left
class CircularPreorder (α : Type*) extends Btw α, SBtw α where
    btw_refl (a : α) : btw a a a
    btw_cyclic_left {a b c : α} : btw a b c → btw b c a
  sbtw := fun a b c => btw a b c ∧ ¬btw c b a
    sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a := by intros; rfl
    sbtw_trans_left {a b c d : α} : sbtw a b c → sbtw b d c → sbtw a d c
Arguments: {α : Type u_1} [self : CircularPreorder α] {a b c d : α}
Goal: sbtw a b c → sbtw b d c → sbtw a d c
-- CircularPartialOrder.btw_antisymm
class CircularPartialOrder (α : Type*) extends CircularPreorder α where
    btw_antisymm {a b c : α} : btw a b c → btw c b a → a = b ∨ b = c ∨ c = a
Arguments: {α : Type u_1} [self : CircularPartialOrder α] {a b c : α}
Goal: btw a b c → btw c b a → a = b ∨ b = c ∨ c = a
-- CircularOrder.btw_total
class CircularOrder (α : Type*) extends CircularPartialOrder α where
    btw_total : ∀ a b c : α, btw a b c ∨ btw c b a
Arguments: {α : Type u_1} [self : CircularOrder α] (a b c : α)
Goal: btw a b c ∨ btw c b a
-- btw_rfl
theorem btw_rfl {a : α} : btw a a a 
Arguments: {α : Type u_1} [CircularPreorder α] {a : α}
Goal: btw a a a
-- Btw.btw.cyclic_left
theorem Btw.btw.cyclic_left {a b c : α} (h : btw a b c) : btw b c a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : btw a b c)
Goal: btw b c a
-- btw_cyclic_right
theorem btw_cyclic_right {a b c : α} (h : btw a b c) : btw c a b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : btw a b c)
Goal: btw c a b
-- btw_cyclic
theorem btw_cyclic {a b c : α} : btw a b c ↔ btw c a b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α}
Goal: btw a b c ↔ btw c a b
-- sbtw_iff_btw_not_btw
theorem sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α}
Goal: sbtw a b c ↔ btw a b c ∧ ¬btw c b a
-- btw_of_sbtw
theorem btw_of_sbtw {a b c : α} (h : sbtw a b c) : btw a b c 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : sbtw a b c)
Goal: btw a b c
-- not_btw_of_sbtw
theorem not_btw_of_sbtw {a b c : α} (h : sbtw a b c) : ¬btw c b a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : sbtw a b c)
Goal: ¬btw c b a
-- not_sbtw_of_btw
theorem not_sbtw_of_btw {a b c : α} (h : btw a b c) : ¬sbtw c b a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : btw a b c)
Goal: ¬sbtw c b a
-- sbtw_of_btw_not_btw
theorem sbtw_of_btw_not_btw {a b c : α} (habc : btw a b c) (hcba : ¬btw c b a) : sbtw a b c 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (habc : btw a b c) (hcba : ¬btw c b a)
Goal: sbtw a b c
-- sbtw_cyclic_left
theorem sbtw_cyclic_left {a b c : α} (h : sbtw a b c) : sbtw b c a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : sbtw a b c)
Goal: sbtw b c a
-- sbtw_cyclic_right
theorem sbtw_cyclic_right {a b c : α} (h : sbtw a b c) : sbtw c a b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : sbtw a b c)
Goal: sbtw c a b
-- sbtw_cyclic
theorem sbtw_cyclic {a b c : α} : sbtw a b c ↔ sbtw c a b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α}
Goal: sbtw a b c ↔ sbtw c a b
-- SBtw.sbtw.trans_left
theorem SBtw.sbtw.trans_left {a b c d : α} (h : sbtw a b c) : sbtw b d c → sbtw a d c 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c d : α} (h : sbtw a b c)
Goal: sbtw b d c → sbtw a d c
-- sbtw_trans_right
theorem sbtw_trans_right {a b c d : α} (hbc : sbtw a b c) (hcd : sbtw a c d) : sbtw a b d 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c d : α} (hbc : sbtw a b c) (hcd : sbtw a c d)
Goal: sbtw a b d
-- sbtw_asymm
theorem sbtw_asymm {a b c : α} (h : sbtw a b c) : ¬sbtw c b a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b c : α} (h : sbtw a b c)
Goal: ¬sbtw c b a
-- sbtw_irrefl_left_right
theorem sbtw_irrefl_left_right {a b : α} : ¬sbtw a b a 
Arguments: {α : Type u_1} [CircularPreorder α] {a b : α}
Goal: ¬sbtw a b a
-- sbtw_irrefl_left
theorem sbtw_irrefl_left {a b : α} : ¬sbtw a a b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b : α}
Goal: ¬sbtw a a b
-- sbtw_irrefl_right
theorem sbtw_irrefl_right {a b : α} : ¬sbtw a b b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b : α}
Goal: ¬sbtw a b b
-- sbtw_irrefl
theorem sbtw_irrefl (a : α) : ¬sbtw a a a 
Arguments: {α : Type u_1} [CircularPreorder α] (a : α)
Goal: ¬sbtw a a a
-- Btw.btw.antisymm
theorem Btw.btw.antisymm {a b c : α} (h : btw a b c) : btw c b a → a = b ∨ b = c ∨ c = a 
Arguments: {α : Type u_1} [CircularPartialOrder α] {a b c : α} (h : btw a b c)
Goal: btw c b a → a = b ∨ b = c ∨ c = a
-- btw_refl_left_right
theorem btw_refl_left_right (a b : α) : btw a b a 
Arguments: {α : Type u_1} [CircularOrder α] (a b : α)
Goal: btw a b a
-- btw_rfl_left_right
theorem btw_rfl_left_right {a b : α} : btw a b a 
Arguments: {α : Type u_1} [CircularOrder α] {a b : α}
Goal: btw a b a
-- btw_refl_left
theorem btw_refl_left (a b : α) : btw a a b 
Arguments: {α : Type u_1} [CircularOrder α] (a b : α)
Goal: btw a a b
-- btw_rfl_left
theorem btw_rfl_left {a b : α} : btw a a b 
Arguments: {α : Type u_1} [CircularOrder α] {a b : α}
Goal: btw a a b
-- btw_refl_right
theorem btw_refl_right (a b : α) : btw a b b 
Arguments: {α : Type u_1} [CircularOrder α] (a b : α)
Goal: btw a b b
-- btw_rfl_right
theorem btw_rfl_right {a b : α} : btw a b b 
Arguments: {α : Type u_1} [CircularOrder α] {a b : α}
Goal: btw a b b
-- sbtw_iff_not_btw
theorem sbtw_iff_not_btw {a b c : α} : sbtw a b c ↔ ¬btw c b a 
Arguments: {α : Type u_1} [CircularOrder α] {a b c : α}
Goal: sbtw a b c ↔ ¬btw c b a
-- btw_iff_not_sbtw
theorem btw_iff_not_sbtw {a b c : α} : btw a b c ↔ ¬sbtw c b a 
Arguments: {α : Type u_1} [CircularOrder α] {a b c : α}
Goal: btw a b c ↔ ¬sbtw c b a
-- Set.mem_cIcc
@[simp]
theorem mem_cIcc {a b x : α} : x ∈ cIcc a b ↔ btw a x b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b x : α}
Goal: x ∈ Set.cIcc a b ↔ btw a x b
-- Set.mem_cIoo
@[simp]
theorem mem_cIoo {a b x : α} : x ∈ cIoo a b ↔ sbtw a x b 
Arguments: {α : Type u_1} [CircularPreorder α] {a b x : α}
Goal: x ∈ Set.cIoo a b ↔ sbtw a x b
-- Set.left_mem_cIcc
theorem left_mem_cIcc (a b : α) : a ∈ cIcc a b 
Arguments: {α : Type u_1} [CircularOrder α] (a b : α)
Goal: a ∈ Set.cIcc a b
-- Set.right_mem_cIcc
theorem right_mem_cIcc (a b : α) : b ∈ cIcc a b 
Arguments: {α : Type u_1} [CircularOrder α] (a b : α)
Goal: b ∈ Set.cIcc a b
-- Set.compl_cIcc
theorem compl_cIcc {a b : α} : (cIcc a b)ᶜ = cIoo b a 
Arguments: {α : Type u_1} [CircularOrder α] {a b : α}
Goal: (Set.cIcc a b)ᶜ = Set.cIoo b a
-- Set.compl_cIoo
theorem compl_cIoo {a b : α} : (cIoo a b)ᶜ = cIcc b a 
Arguments: {α : Type u_1} [CircularOrder α] {a b : α}
Goal: (Set.cIoo a b)ᶜ = Set.cIcc b a
-- MonotoneOn.exists_monotone_extension
theorem MonotoneOn.exists_monotone_extension (h : MonotoneOn f s) (hl : BddBelow (f '' s))
    (hu : BddAbove (f '' s)) : ∃ g : α → β, Monotone g ∧ EqOn f g s 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder α] [ConditionallyCompleteLinearOrder β] {f : α → β} {s : Set α} (h : MonotoneOn f s) (hl : BddBelow (f '' s)) (hu : BddAbove (f '' s))
Goal: ∃ g, Monotone g ∧ Set.EqOn f g s
-- AntitoneOn.exists_antitone_extension
theorem AntitoneOn.exists_antitone_extension (h : AntitoneOn f s) (hl : BddBelow (f '' s))
    (hu : BddAbove (f '' s)) : ∃ g : α → β, Antitone g ∧ EqOn f g s 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder α] [ConditionallyCompleteLinearOrder β] {f : α → β} {s : Set α} (h : AntitoneOn f s) (hl : BddBelow (f '' s)) (hu : BddAbove (f '' s))
Goal: ∃ g, Antitone g ∧ Set.EqOn f g s
-- iSup_ulift
@[simp] lemma iSup_ulift {ι : Type*} [SupSet α] (f : ULift ι → α) :
    ⨆ i : ULift ι, f i = ⨆ i, f (.up i) 
Arguments: {α : Type u_1} {ι : Type u_9} [SupSet α] (f : ULift.{u_10, u_9} ι → α)
Goal: ⨆ i, f i = ⨆ i, f { down := i }
-- iInf_ulift
@[simp] lemma iInf_ulift {ι : Type*} [InfSet α] (f : ULift ι → α) :
    ⨅ i : ULift ι, f i = ⨅ i, f (.up i) 
Arguments: {α : Type u_1} {ι : Type u_9} [InfSet α] (f : ULift.{u_10, u_9} ι → α)
Goal: ⨅ i, f i = ⨅ i, f { down := i }
-- CompleteSemilatticeSup.le_sSup
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
    le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
    sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a
Arguments: {α : Type u_9} [self : CompleteSemilatticeSup α] (s : Set α) (a : α)
Goal: a ∈ s → a ≤ sSup s
-- CompleteSemilatticeSup.sSup_le
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
    le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
    sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a
Arguments: {α : Type u_9} [self : CompleteSemilatticeSup α] (s : Set α) (a : α)
Goal: (∀ b ∈ s, b ≤ a) → sSup s ≤ a
-- le_sSup
theorem le_sSup : a ∈ s → a ≤ sSup s 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a : α}
Goal: a ∈ s → a ≤ sSup s
-- sSup_le
theorem sSup_le : (∀ b ∈ s, b ≤ a) → sSup s ≤ a 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a : α}
Goal: (∀ b ∈ s, b ≤ a) → sSup s ≤ a
-- isLUB_sSup
theorem isLUB_sSup (s : Set α) : IsLUB s (sSup s) 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] (s : Set α)
Goal: IsLUB s (sSup s)
-- isLUB_iff_sSup_eq
lemma isLUB_iff_sSup_eq : IsLUB s a ↔ sSup s = a 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a : α}
Goal: IsLUB s a ↔ sSup s = a
-- le_sSup_of_le
theorem le_sSup_of_le (hb : b ∈ s) (h : a ≤ b) : a ≤ sSup s 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a b : α} (hb : b ∈ s) (h : a ≤ b)
Goal: a ≤ sSup s
-- sSup_le_sSup
@[gcongr]
theorem sSup_le_sSup (h : s ⊆ t) : sSup s ≤ sSup t 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s t : Set α} (h : s ⊆ t)
Goal: sSup s ≤ sSup t
-- sSup_le_iff
@[simp]
theorem sSup_le_iff : sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a : α}
Goal: sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a
-- le_sSup_iff
theorem le_sSup_iff : a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s : Set α} {a : α}
Goal: a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b
-- le_iSup_iff
theorem le_iSup_iff {s : ι → α} : a ≤ iSup s ↔ ∀ b, (∀ i, s i ≤ b) → a ≤ b 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteSemilatticeSup α] {a : α} {s : ι → α}
Goal: a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b
-- sSup_le_sSup_of_forall_exists_le
theorem sSup_le_sSup_of_forall_exists_le (h : ∀ x ∈ s, ∃ y ∈ t, x ≤ y) : sSup s ≤ sSup t 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {s t : Set α} (h : ∀ x ∈ s, ∃ y ∈ t, x ≤ y)
Goal: sSup s ≤ sSup t
-- sSup_singleton
theorem sSup_singleton {a : α} : sSup {a} = a 
Arguments: {α : Type u_1} [CompleteSemilatticeSup α] {a : α}
Goal: sSup {a} = a
-- CompleteSemilatticeInf.le_sInf
class CompleteSemilatticeInf (α : Type*) extends PartialOrder α, InfSet α where
    sInf_le : ∀ s, ∀ a ∈ s, sInf s ≤ a
    le_sInf : ∀ s a, (∀ b ∈ s, a ≤ b) → a ≤ sInf s
Arguments: {α : Type u_9} [self : CompleteSemilatticeInf α] (s : Set α) (a : α)
Goal: (∀ b ∈ s, a ≤ b) → a ≤ sInf s
-- CompleteSemilatticeInf.sInf_le
class CompleteSemilatticeInf (α : Type*) extends PartialOrder α, InfSet α where
    sInf_le : ∀ s, ∀ a ∈ s, sInf s ≤ a
    le_sInf : ∀ s a, (∀ b ∈ s, a ≤ b) → a ≤ sInf s
Arguments: {α : Type u_9} [self : CompleteSemilatticeInf α] (s : Set α) (a : α)
Goal: a ∈ s → sInf s ≤ a
-- sInf_le
theorem sInf_le : a ∈ s → sInf s ≤ a 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a : α}
Goal: a ∈ s → sInf s ≤ a
-- le_sInf
theorem le_sInf : (∀ b ∈ s, a ≤ b) → a ≤ sInf s 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a : α}
Goal: (∀ b ∈ s, a ≤ b) → a ≤ sInf s
-- isGLB_sInf
theorem isGLB_sInf (s : Set α) : IsGLB s (sInf s) 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] (s : Set α)
Goal: IsGLB s (sInf s)
-- isGLB_iff_sInf_eq
lemma isGLB_iff_sInf_eq : IsGLB s a ↔ sInf s = a 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a : α}
Goal: IsGLB s a ↔ sInf s = a
-- sInf_le_of_le
theorem sInf_le_of_le (hb : b ∈ s) (h : b ≤ a) : sInf s ≤ a 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a b : α} (hb : b ∈ s) (h : b ≤ a)
Goal: sInf s ≤ a
-- sInf_le_sInf
@[gcongr]
theorem sInf_le_sInf (h : s ⊆ t) : sInf t ≤ sInf s 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s t : Set α} (h : s ⊆ t)
Goal: sInf t ≤ sInf s
-- le_sInf_iff
@[simp]
theorem le_sInf_iff : a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a : α}
Goal: a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b
-- sInf_le_iff
theorem sInf_le_iff : sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s : Set α} {a : α}
Goal: sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a
-- iInf_le_iff
theorem iInf_le_iff {s : ι → α} : iInf s ≤ a ↔ ∀ b, (∀ i, b ≤ s i) → b ≤ a 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteSemilatticeInf α] {a : α} {s : ι → α}
Goal: iInf s ≤ a ↔ ∀ (b : α), (∀ (i : ι), b ≤ s i) → b ≤ a
-- sInf_le_sInf_of_forall_exists_le
theorem sInf_le_sInf_of_forall_exists_le (h : ∀ x ∈ s, ∃ y ∈ t, y ≤ x) : sInf t ≤ sInf s 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {s t : Set α} (h : ∀ x ∈ s, ∃ y ∈ t, y ≤ x)
Goal: sInf t ≤ sInf s
-- sInf_singleton
theorem sInf_singleton {a : α} : sInf {a} = a 
Arguments: {α : Type u_1} [CompleteSemilatticeInf α] {a : α}
Goal: sInf {a} = a
-- CompleteLattice.le_top
class CompleteLattice (α : Type*) extends Lattice α, CompleteSemilatticeSup α,
  CompleteSemilatticeInf α, Top α, Bot α where
    protected le_top : ∀ x : α, x ≤ ⊤
    protected bot_le : ∀ x : α, ⊥ ≤ x
Arguments: {α : Type u_9} [self : CompleteLattice α] (x : α)
Goal: x ≤ ⊤
-- CompleteLattice.bot_le
class CompleteLattice (α : Type*) extends Lattice α, CompleteSemilatticeSup α,
  CompleteSemilatticeInf α, Top α, Bot α where
    protected le_top : ∀ x : α, x ≤ ⊤
    protected bot_le : ∀ x : α, ⊥ ≤ x
Arguments: {α : Type u_9} [self : CompleteLattice α] (x : α)
Goal: ⊥ ≤ x
-- CompleteLinearOrder.le_total
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
    le_total (a b : α) : a ≤ b ∨ b ≤ a
    decidableLE : DecidableRel (· ≤ · : α → α → Prop)
    decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
    decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
Arguments: {α : Type u_9} [self : CompleteLinearOrder α] (a b : α)
Goal: a ≤ b ∨ b ≤ a
-- toDual_sSup
@[simp]
theorem toDual_sSup (s : Set α) : toDual (sSup s) = sInf (ofDual ⁻¹' s) 
Arguments: {α : Type u_1} [CompleteLattice α] (s : Set α)
Goal: OrderDual.toDual (sSup s) = sInf (⇑OrderDual.ofDual ⁻¹' s)
-- toDual_sInf
@[simp]
theorem toDual_sInf (s : Set α) : toDual (sInf s) = sSup (ofDual ⁻¹' s) 
Arguments: {α : Type u_1} [CompleteLattice α] (s : Set α)
Goal: OrderDual.toDual (sInf s) = sSup (⇑OrderDual.ofDual ⁻¹' s)
-- ofDual_sSup
@[simp]
theorem ofDual_sSup (s : Set αᵒᵈ) : ofDual (sSup s) = sInf (toDual ⁻¹' s) 
Arguments: {α : Type u_1} [CompleteLattice α] (s : Set αᵒᵈ)
Goal: OrderDual.ofDual (sSup s) = sInf (⇑OrderDual.toDual ⁻¹' s)
-- ofDual_sInf
@[simp]
theorem ofDual_sInf (s : Set αᵒᵈ) : ofDual (sInf s) = sSup (toDual ⁻¹' s) 
Arguments: {α : Type u_1} [CompleteLattice α] (s : Set αᵒᵈ)
Goal: OrderDual.ofDual (sInf s) = sSup (⇑OrderDual.toDual ⁻¹' s)
-- toDual_iSup
@[simp]
theorem toDual_iSup (f : ι → α) : toDual (⨆ i, f i) = ⨅ i, toDual (f i) 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteLattice α] (f : ι → α)
Goal: OrderDual.toDual (⨆ i, f i) = ⨅ i, OrderDual.toDual (f i)
-- toDual_iInf
@[simp]
theorem toDual_iInf (f : ι → α) : toDual (⨅ i, f i) = ⨆ i, toDual (f i) 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteLattice α] (f : ι → α)
Goal: OrderDual.toDual (⨅ i, f i) = ⨆ i, OrderDual.toDual (f i)
-- ofDual_iSup
@[simp]
theorem ofDual_iSup (f : ι → αᵒᵈ) : ofDual (⨆ i, f i) = ⨅ i, ofDual (f i) 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteLattice α] (f : ι → αᵒᵈ)
Goal: OrderDual.ofDual (⨆ i, f i) = ⨅ i, OrderDual.ofDual (f i)