ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Order.isSuccLimit_of_dense
@[simp]
theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a 
Arguments: {α : Type u_1} [LT α] [DenselyOrdered α] (a : α)
Goal: Order.IsSuccLimit a
-- IsMin.isSuccLimit
protected theorem _root_.IsMin.isSuccLimit : IsMin a → IsSuccLimit a 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: IsMin a → Order.IsSuccLimit a
-- Order.isSuccLimit_bot
theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) 
Arguments: {α : Type u_1} [Preorder α] [OrderBot α]
Goal: Order.IsSuccLimit ⊥
-- Order.IsSuccLimit.isMax
protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] (h : Order.IsSuccLimit (Order.succ a))
Goal: IsMax a
-- Order.not_isSuccLimit_succ_of_not_isMax
theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] (ha : ¬IsMax a)
Goal: ¬Order.IsSuccLimit (Order.succ a)
-- Order.IsSuccLimit.succ_ne
theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] [NoMaxOrder α] (h : Order.IsSuccLimit a) (b : α)
Goal: Order.succ b ≠ a
-- Order.not_isSuccLimit_succ
@[simp]
theorem not_isSuccLimit_succ (a : α) : ¬IsSuccLimit (succ a) 
Arguments: {α : Type u_1} [Preorder α] [SuccOrder α] [NoMaxOrder α] (a : α)
Goal: ¬Order.IsSuccLimit (Order.succ a)
-- Order.IsSuccLimit.isMin_of_noMax
theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] [IsSuccArchimedean α] [NoMaxOrder α] (h : Order.IsSuccLimit a)
Goal: IsMin a
-- Order.isSuccLimit_iff_of_noMax
@[simp]
theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] [IsSuccArchimedean α] [NoMaxOrder α]
Goal: Order.IsSuccLimit a ↔ IsMin a
-- Order.not_isSuccLimit_of_noMax
theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [SuccOrder α] [IsSuccArchimedean α] [NoMinOrder α] [NoMaxOrder α]
Goal: ¬Order.IsSuccLimit a
-- Order.isSuccLimit_of_succ_ne
theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} (h : ∀ (b : α), Order.succ b ≠ a)
Goal: Order.IsSuccLimit a
-- Order.not_isSuccLimit_iff
theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α}
Goal: ¬Order.IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ Order.succ b = a
-- Order.mem_range_succ_of_not_isSuccLimit
theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} (h : ¬Order.IsSuccLimit a)
Goal: a ∈ Set.range Order.succ
-- Order.isSuccLimit_of_succ_lt
theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {b : α} (H : ∀ a < b, Order.succ a < b)
Goal: Order.IsSuccLimit b
-- Order.IsSuccLimit.succ_lt
theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a b : α} (hb : Order.IsSuccLimit b) (ha : a < b)
Goal: Order.succ a < b
-- Order.IsSuccLimit.succ_lt_iff
theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a b : α} (hb : Order.IsSuccLimit b)
Goal: Order.succ a < b ↔ a < b
-- Order.isSuccLimit_iff_succ_lt
theorem isSuccLimit_iff_succ_lt : IsSuccLimit b ↔ ∀ a < b, succ a < b 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {b : α}
Goal: Order.IsSuccLimit b ↔ ∀ a < b, Order.succ a < b
-- Order.isSuccLimitRecOn_limit
theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {b : α} {C : α → Sort u_2} (hs : (a : α) → ¬IsMax a → C (Order.succ a)) (hl : (a : α) → Order.IsSuccLimit a → C a) (hb : Order.IsSuccLimit b)
Goal: Order.isSuccLimitRecOn b hs hl = hl b hb
-- Order.isSuccLimitRecOn_succ'
theorem isSuccLimitRecOn_succ' (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
    {b : α} (hb : ¬IsMax b) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b hb 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {C : α → Sort u_2} (hs : (a : α) → ¬IsMax a → C (Order.succ a)) (hl : (a : α) → Order.IsSuccLimit a → C a) {b : α} (hb : ¬IsMax b)
Goal: Order.isSuccLimitRecOn (Order.succ b) hs hl = hs b hb
-- SuccOrder.limitRecOn_succ
@[simp]
theorem _root_.SuccOrder.limitRecOn_succ (ha : ¬ IsMax a) :
    SuccOrder.limitRecOn (succ a) H_succ H_lim
      = H_succ a ha (SuccOrder.limitRecOn a H_succ H_lim) 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} {C : α → Sort u_2} [WellFoundedLT α] (H_succ : (a : α) → ¬IsMax a → C a → C (Order.succ a)) (H_lim : (a : α) → Order.IsSuccLimit a → ((b : α) → b < a → C b) → C a) (ha : ¬IsMax a)
Goal: SuccOrder.limitRecOn (Order.succ a) H_succ H_lim = H_succ a ha (SuccOrder.limitRecOn a H_succ H_lim)
-- SuccOrder.limitRecOn_limit
@[simp]
theorem _root_.SuccOrder.limitRecOn_limit (ha : IsSuccLimit a) :
    SuccOrder.limitRecOn a H_succ H_lim
      = H_lim a ha fun x _ ↦ SuccOrder.limitRecOn x H_succ H_lim 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} {C : α → Sort u_2} [WellFoundedLT α] (H_succ : (a : α) → ¬IsMax a → C a → C (Order.succ a)) (H_lim : (a : α) → Order.IsSuccLimit a → ((b : α) → b < a → C b) → C a) (ha : Order.IsSuccLimit a)
Goal: SuccOrder.limitRecOn a H_succ H_lim = H_lim a ha fun x x_1 => SuccOrder.limitRecOn x H_succ H_lim
-- Order.isSuccLimitRecOn_succ
@[simp]
theorem isSuccLimitRecOn_succ (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
    (b : α) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b (not_isMax b) 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {C : α → Sort u_2} [NoMaxOrder α] (hs : (a : α) → ¬IsMax a → C (Order.succ a)) (hl : (a : α) → Order.IsSuccLimit a → C a) (b : α)
Goal: Order.isSuccLimitRecOn (Order.succ b) hs hl = hs b ⋯
-- Order.isSuccLimit_iff_succ_ne
theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} [NoMaxOrder α]
Goal: Order.IsSuccLimit a ↔ ∀ (b : α), Order.succ b ≠ a
-- Order.not_isSuccLimit_iff'
theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} [NoMaxOrder α]
Goal: ¬Order.IsSuccLimit a ↔ a ∈ Set.range Order.succ
-- Order.IsSuccLimit.isMin
protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} [IsSuccArchimedean α] (h : Order.IsSuccLimit a)
Goal: IsMin a
-- Order.isSuccLimit_iff
@[simp]
theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} [IsSuccArchimedean α]
Goal: Order.IsSuccLimit a ↔ IsMin a
-- Order.not_isSuccLimit
theorem not_isSuccLimit [NoMinOrder α] : ¬IsSuccLimit a 
Arguments: {α : Type u_1} [PartialOrder α] [SuccOrder α] {a : α} [IsSuccArchimedean α] [NoMinOrder α]
Goal: ¬Order.IsSuccLimit a
-- Order.not_isPredLimit_iff_exists_covBy
theorem not_isPredLimit_iff_exists_covBy (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b 
Arguments: {α : Type u_1} [LT α] (a : α)
Goal: ¬Order.IsPredLimit a ↔ ∃ b, a ⋖ b
-- Order.isPredLimit_of_dense
theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a 
Arguments: {α : Type u_1} [LT α] [DenselyOrdered α] (a : α)
Goal: Order.IsPredLimit a
-- Order.isSuccLimit_toDual_iff
@[simp]
theorem isSuccLimit_toDual_iff : IsSuccLimit (toDual a) ↔ IsPredLimit a 
Arguments: {α : Type u_1} [LT α] {a : α}
Goal: Order.IsSuccLimit (OrderDual.toDual a) ↔ Order.IsPredLimit a
-- Order.isPredLimit_toDual_iff
@[simp]
theorem isPredLimit_toDual_iff : IsPredLimit (toDual a) ↔ IsSuccLimit a 
Arguments: {α : Type u_1} [LT α] {a : α}
Goal: Order.IsPredLimit (OrderDual.toDual a) ↔ Order.IsSuccLimit a
-- IsMax.isPredLimit
protected theorem _root_.IsMax.isPredLimit : IsMax a → IsPredLimit a 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: IsMax a → Order.IsPredLimit a
-- Order.isPredLimit_top
theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) 
Arguments: {α : Type u_1} [Preorder α] [OrderTop α]
Goal: Order.IsPredLimit ⊤
-- Order.IsPredLimit.isMin
protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] (h : Order.IsPredLimit (Order.pred a))
Goal: IsMin a
-- Order.not_isPredLimit_pred_of_not_isMin
theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] (ha : ¬IsMin a)
Goal: ¬Order.IsPredLimit (Order.pred a)
-- Order.IsPredLimit.pred_ne
theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] [NoMinOrder α] (h : Order.IsPredLimit a) (b : α)
Goal: Order.pred b ≠ a
-- Order.not_isPredLimit_pred
@[simp]
theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a) 
Arguments: {α : Type u_1} [Preorder α] [PredOrder α] [NoMinOrder α] (a : α)
Goal: ¬Order.IsPredLimit (Order.pred a)
-- Order.IsPredLimit.isMax_of_noMin
protected theorem IsPredLimit.isMax_of_noMin [NoMinOrder α] (h : IsPredLimit a) : IsMax a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] [IsPredArchimedean α] [NoMinOrder α] (h : Order.IsPredLimit a)
Goal: IsMax a
-- Order.isPredLimit_iff_of_noMin
@[simp]
theorem isPredLimit_iff_of_noMin [NoMinOrder α] : IsPredLimit a ↔ IsMax a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] [IsPredArchimedean α] [NoMinOrder α]
Goal: Order.IsPredLimit a ↔ IsMax a
-- Order.not_isPredLimit_of_noMin
theorem not_isPredLimit_of_noMin [NoMinOrder α] [NoMaxOrder α] : ¬IsPredLimit a 
Arguments: {α : Type u_1} [Preorder α] {a : α} [PredOrder α] [IsPredArchimedean α] [NoMinOrder α] [NoMaxOrder α]
Goal: ¬Order.IsPredLimit a
-- Order.isPredLimit_of_pred_ne
theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} (h : ∀ (b : α), Order.pred b ≠ a)
Goal: Order.IsPredLimit a
-- Order.not_isPredLimit_iff
theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α}
Goal: ¬Order.IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ Order.pred b = a
-- Order.mem_range_pred_of_not_isPredLimit
theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} (h : ¬Order.IsPredLimit a)
Goal: a ∈ Set.range Order.pred
-- Order.isPredLimit_of_pred_lt
theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {b : α} (H : ∀ a > b, Order.pred a < b)
Goal: Order.IsPredLimit b
-- Order.IsPredLimit.lt_pred
theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a b : α} (h : Order.IsPredLimit a)
Goal: a < b → a < Order.pred b
-- Order.IsPredLimit.lt_pred_iff
theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a b : α} (h : Order.IsPredLimit a)
Goal: a < Order.pred b ↔ a < b
-- Order.isPredLimit_iff_lt_pred
theorem isPredLimit_iff_lt_pred : IsPredLimit a ↔ ∀ ⦃b⦄, a < b → a < pred b 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α}
Goal: Order.IsPredLimit a ↔ ∀ ⦃b : α⦄, a < b → a < Order.pred b
-- Order.isPredLimitRecOn_limit
theorem isPredLimitRecOn_limit (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
    (hb : IsPredLimit b) : @isPredLimitRecOn α _ _ C b hs hl = hl b hb 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {b : α} {C : α → Sort u_2} (hs : (a : α) → ¬IsMin a → C (Order.pred a)) (hl : (a : α) → Order.IsPredLimit a → C a) (hb : Order.IsPredLimit b)
Goal: Order.isPredLimitRecOn b hs hl = hl b hb
-- Order.isPredLimitRecOn_pred'
theorem isPredLimitRecOn_pred' (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
    {b : α} (hb : ¬IsMin b) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b hb 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {C : α → Sort u_2} (hs : (a : α) → ¬IsMin a → C (Order.pred a)) (hl : (a : α) → Order.IsPredLimit a → C a) {b : α} (hb : ¬IsMin b)
Goal: Order.isPredLimitRecOn (Order.pred b) hs hl = hs b hb
-- PredOrder.limitRecOn_pred
@[simp]
theorem _root_.PredOrder.limitRecOn_pred (ha : ¬ IsMin a) :
    PredOrder.limitRecOn (pred a) H_pred H_lim
      = H_pred a ha (PredOrder.limitRecOn a H_pred H_lim) 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} {C : α → Sort u_2} [WellFoundedGT α] (H_pred : (a : α) → ¬IsMin a → C a → C (Order.pred a)) (H_lim : (a : α) → Order.IsPredLimit a → ((b : α) → b > a → C b) → C a) (ha : ¬IsMin a)
Goal: PredOrder.limitRecOn (Order.pred a) H_pred H_lim = H_pred a ha (PredOrder.limitRecOn a H_pred H_lim)
-- PredOrder.limitRecOn_limit
@[simp]
theorem _root_.PredOrder.limitRecOn_limit (ha : IsPredLimit a) :
    PredOrder.limitRecOn a H_pred H_lim
      = H_lim a ha fun x _ ↦ PredOrder.limitRecOn x H_pred H_lim 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} {C : α → Sort u_2} [WellFoundedGT α] (H_pred : (a : α) → ¬IsMin a → C a → C (Order.pred a)) (H_lim : (a : α) → Order.IsPredLimit a → ((b : α) → b > a → C b) → C a) (ha : Order.IsPredLimit a)
Goal: PredOrder.limitRecOn a H_pred H_lim = H_lim a ha fun x x_1 => PredOrder.limitRecOn x H_pred H_lim
-- Order.isPredLimitRecOn_pred
@[simp]
theorem isPredLimitRecOn_pred (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
    (b : α) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b (not_isMin b) 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {C : α → Sort u_2} [NoMinOrder α] (hs : (a : α) → ¬IsMin a → C (Order.pred a)) (hl : (a : α) → Order.IsPredLimit a → C a) (b : α)
Goal: Order.isPredLimitRecOn (Order.pred b) hs hl = hs b ⋯
-- Order.IsPredLimit.isMax
protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} [IsPredArchimedean α] (h : Order.IsPredLimit a)
Goal: IsMax a
-- Order.isPredLimit_iff
@[simp]
theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} [IsPredArchimedean α]
Goal: Order.IsPredLimit a ↔ IsMax a
-- Order.not_isPredLimit
theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a 
Arguments: {α : Type u_1} [PartialOrder α] [PredOrder α] {a : α} [IsPredArchimedean α] [NoMaxOrder α]
Goal: ¬Order.IsPredLimit a
-- UpperSet.coe_iciSupHom
@[simp]
theorem coe_iciSupHom : (iciSupHom : α → UpperSet α) = Ici 
Arguments: {α : Type u_1} [SemilatticeSup α]
Goal: ⇑UpperSet.iciSupHom = UpperSet.Ici
-- UpperSet.iciSupHom_apply
@[simp]
theorem iciSupHom_apply (a : α) : iciSupHom a = Ici a 
Arguments: {α : Type u_1} [SemilatticeSup α] (a : α)
Goal: UpperSet.iciSupHom a = UpperSet.Ici a
-- UpperSet.coe_icisSupHom
@[simp]
theorem coe_icisSupHom : (icisSupHom : α → UpperSet α) = Ici 
Arguments: {α : Type u_1} [CompleteLattice α]
Goal: ⇑UpperSet.icisSupHom = UpperSet.Ici
-- UpperSet.icisSupHom_apply
@[simp]
theorem icisSupHom_apply (a : α) : icisSupHom a = Ici a 
Arguments: {α : Type u_1} [CompleteLattice α] (a : α)
Goal: UpperSet.icisSupHom a = UpperSet.Ici a
-- LowerSet.coe_iicInfHom
@[simp]
theorem coe_iicInfHom : (iicInfHom : α → LowerSet α) = Iic 
Arguments: {α : Type u_1} [SemilatticeInf α]
Goal: ⇑LowerSet.iicInfHom = LowerSet.Iic
-- LowerSet.iicInfHom_apply
@[simp]
theorem iicInfHom_apply (a : α) : iicInfHom a = Iic a 
Arguments: {α : Type u_1} [SemilatticeInf α] (a : α)
Goal: LowerSet.iicInfHom a = LowerSet.Iic a
-- LowerSet.coe_iicsInfHom
@[simp]
theorem coe_iicsInfHom : (iicsInfHom : α → LowerSet α) = Iic 
Arguments: {α : Type u_1} [CompleteLattice α]
Goal: ⇑LowerSet.iicsInfHom = LowerSet.Iic
-- LowerSet.iicsInfHom_apply
@[simp]
theorem iicsInfHom_apply (a : α) : iicsInfHom a = Iic a 
Arguments: {α : Type u_1} [CompleteLattice α] (a : α)
Goal: LowerSet.iicsInfHom a = LowerSet.Iic a
-- Set.Finite.upperClosure
protected theorem Finite.upperClosure [LocallyFiniteOrderTop α] (hs : s.Finite) :
    (upperClosure s : Set α).Finite 
Arguments: {α : Type u_1} [Preorder α] {s : Set α} [LocallyFiniteOrderTop α] (hs : s.Finite)
Goal: (↑(upperClosure s)).Finite
-- Set.Finite.lowerClosure
protected theorem Finite.lowerClosure [LocallyFiniteOrderBot α] (hs : s.Finite) :
    (lowerClosure s : Set α).Finite 
Arguments: {α : Type u_1} [Preorder α] {s : Set α} [LocallyFiniteOrderBot α] (hs : s.Finite)
Goal: (↑(lowerClosure s)).Finite
-- Set.mem_sInter
@[simp]
theorem mem_sInter {x : α} {S : Set (Set α)} : x ∈ ⋂₀ S ↔ ∀ t ∈ S, x ∈ t 
Arguments: {α : Type u} {x : α} {S : Set (Set α)}
Goal: x ∈ ⋂₀ S ↔ ∀ (t : Set α), t ∈ S → x ∈ t
-- Set.mem_sUnion
@[simp]
theorem mem_sUnion {x : α} {S : Set (Set α)} : x ∈ ⋃₀ S ↔ ∃ t ∈ S, x ∈ t 
Arguments: {α : Type u} {x : α} {S : Set (Set α)}
Goal: x ∈ ⋃₀ S ↔ ∃ t, t ∈ S ∧ x ∈ t
-- Set.mem_iUnion
@[simp]
theorem mem_iUnion {x : α} {s : ι → Set α} : (x ∈ ⋃ i, s i) ↔ ∃ i, x ∈ s i 
Arguments: {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}
Goal: x ∈ ⋃ i, s i ↔ ∃ i, x ∈ s i
-- Set.mem_iInter
@[simp]
theorem mem_iInter {x : α} {s : ι → Set α} : (x ∈ ⋂ i, s i) ↔ ∀ i, x ∈ s i 
Arguments: {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}
Goal: x ∈ ⋂ i, s i ↔ ∀ (i : ι), x ∈ s i
-- Set.sSup_eq_sUnion
@[simp]
theorem sSup_eq_sUnion (S : Set (Set α)) : sSup S = ⋃₀S 
Arguments: {α : Type u} (S : Set (Set α))
Goal: sSup S = ⋃₀ S
-- Set.sInf_eq_sInter
@[simp]
theorem sInf_eq_sInter (S : Set (Set α)) : sInf S = ⋂₀ S 
Arguments: {α : Type u} (S : Set (Set α))
Goal: sInf S = ⋂₀ S
-- Set.iSup_eq_iUnion
@[simp]
theorem iSup_eq_iUnion (s : ι → Set α) : iSup s = iUnion s 
Arguments: {α : Type u} {ι : Sort v} (s : ι → Set α)
Goal: iSup s = Set.iUnion s
-- Set.iInf_eq_iInter
@[simp]
theorem iInf_eq_iInter (s : ι → Set α) : iInf s = iInter s 
Arguments: {α : Type u} {ι : Sort v} (s : ι → Set α)
Goal: iInf s = Set.iInter s
-- WCovBy.le
theorem WCovBy.le (h : a ⩿ b) : a ≤ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h : a ⩿ b)
Goal: a ≤ b
-- WCovBy.refl
theorem WCovBy.refl (a : α) : a ⩿ a 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: a ⩿ a
-- WCovBy.rfl
@[simp] lemma WCovBy.rfl : a ⩿ a 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: a ⩿ a
-- Eq.wcovBy
protected theorem Eq.wcovBy (h : a = b) : a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h : a = b)
Goal: a ⩿ b
-- wcovBy_of_le_of_le
theorem wcovBy_of_le_of_le (h1 : a ≤ b) (h2 : b ≤ a) : a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h1 : a ≤ b) (h2 : b ≤ a)
Goal: a ⩿ b
-- AntisymmRel.wcovBy
theorem AntisymmRel.wcovBy (h : AntisymmRel (· ≤ ·) a b) : a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h : AntisymmRel (fun x x_1 => x ≤ x_1) a b)
Goal: a ⩿ b
-- WCovBy.wcovBy_iff_le
theorem WCovBy.wcovBy_iff_le (hab : a ⩿ b) : b ⩿ a ↔ b ≤ a 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (hab : a ⩿ b)
Goal: b ⩿ a ↔ b ≤ a
-- wcovBy_of_eq_or_eq
theorem wcovBy_of_eq_or_eq (hab : a ≤ b) (h : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b) : a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (hab : a ≤ b) (h : ∀ (c : α), a ≤ c → c ≤ b → c = a ∨ c = b)
Goal: a ⩿ b
-- AntisymmRel.trans_wcovBy
theorem AntisymmRel.trans_wcovBy (hab : AntisymmRel (· ≤ ·) a b) (hbc : b ⩿ c) : a ⩿ c 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hab : AntisymmRel (fun x x_1 => x ≤ x_1) a b) (hbc : b ⩿ c)
Goal: a ⩿ c
-- wcovBy_congr_left
theorem wcovBy_congr_left (hab : AntisymmRel (· ≤ ·) a b) : a ⩿ c ↔ b ⩿ c 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hab : AntisymmRel (fun x x_1 => x ≤ x_1) a b)
Goal: a ⩿ c ↔ b ⩿ c
-- WCovBy.trans_antisymm_rel
theorem WCovBy.trans_antisymm_rel (hab : a ⩿ b) (hbc : AntisymmRel (· ≤ ·) b c) : a ⩿ c 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hab : a ⩿ b) (hbc : AntisymmRel (fun x x_1 => x ≤ x_1) b c)
Goal: a ⩿ c
-- wcovBy_congr_right
theorem wcovBy_congr_right (hab : AntisymmRel (· ≤ ·) a b) : c ⩿ a ↔ c ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hab : AntisymmRel (fun x x_1 => x ≤ x_1) a b)
Goal: c ⩿ a ↔ c ⩿ b
-- not_wcovBy_iff
theorem not_wcovBy_iff (h : a ≤ b) : ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h : a ≤ b)
Goal: ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b
-- WCovBy.Ioo_eq
theorem WCovBy.Ioo_eq (h : a ⩿ b) : Ioo a b = ∅ 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (h : a ⩿ b)
Goal: Set.Ioo a b = ∅
-- wcovBy_iff_Ioo_eq
theorem wcovBy_iff_Ioo_eq : a ⩿ b ↔ a ≤ b ∧ Ioo a b = ∅ 
Arguments: {α : Type u_1} [Preorder α] {a b : α}
Goal: a ⩿ b ↔ a ≤ b ∧ Set.Ioo a b = ∅
-- WCovBy.of_le_of_le
lemma WCovBy.of_le_of_le (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c) : b ⩿ c 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c)
Goal: b ⩿ c
-- WCovBy.of_le_of_le'
lemma WCovBy.of_le_of_le' (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c) : a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b c : α} (hac : a ⩿ c) (hab : a ≤ b) (hbc : b ≤ c)
Goal: a ⩿ b
-- WCovBy.of_image
theorem WCovBy.of_image (f : α ↪o β) (h : f a ⩿ f b) : a ⩿ b 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {a b : α} (f : α ↪o β) (h : f a ⩿ f b)
Goal: a ⩿ b
-- WCovBy.image
theorem WCovBy.image (f : α ↪o β) (hab : a ⩿ b) (h : (range f).OrdConnected) : f a ⩿ f b 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {a b : α} (f : α ↪o β) (hab : a ⩿ b) (h : (Set.range ⇑f).OrdConnected)
Goal: f a ⩿ f b
-- Set.OrdConnected.apply_wcovBy_apply_iff
theorem Set.OrdConnected.apply_wcovBy_apply_iff (f : α ↪o β) (h : (range f).OrdConnected) :
    f a ⩿ f b ↔ a ⩿ b 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {a b : α} (f : α ↪o β) (h : (Set.range ⇑f).OrdConnected)
Goal: f a ⩿ f b ↔ a ⩿ b
-- apply_wcovBy_apply_iff
@[simp]
theorem apply_wcovBy_apply_iff {E : Type*} [EquivLike E α β] [OrderIsoClass E α β] (e : E) :
    e a ⩿ e b ↔ a ⩿ b 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {a b : α} {E : Type u_3} [EquivLike E α β] [OrderIsoClass E α β] (e : E)
Goal: e a ⩿ e b ↔ a ⩿ b
-- toDual_wcovBy_toDual_iff
@[simp]
theorem toDual_wcovBy_toDual_iff : toDual b ⩿ toDual a ↔ a ⩿ b 
Arguments: {α : Type u_1} [Preorder α] {a b : α}
Goal: OrderDual.toDual b ⩿ OrderDual.toDual a ↔ a ⩿ b
-- ofDual_wcovBy_ofDual_iff
@[simp]
theorem ofDual_wcovBy_ofDual_iff {a b : αᵒᵈ} : ofDual a ⩿ ofDual b ↔ b ⩿ a 
Arguments: {α : Type u_1} [Preorder α] {a b : αᵒᵈ}
Goal: OrderDual.ofDual a ⩿ OrderDual.ofDual b ↔ b ⩿ a
-- WCovBy.eq_or_eq
theorem WCovBy.eq_or_eq (h : a ⩿ b) (h2 : a ≤ c) (h3 : c ≤ b) : c = a ∨ c = b 
Arguments: {α : Type u_1} [PartialOrder α] {a b c : α} (h : a ⩿ b) (h2 : a ≤ c) (h3 : c ≤ b)
Goal: c = a ∨ c = b
-- wcovBy_iff_le_and_eq_or_eq
theorem wcovBy_iff_le_and_eq_or_eq : a ⩿ b ↔ a ≤ b ∧ ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α}
Goal: a ⩿ b ↔ a ≤ b ∧ ∀ (c : α), a ≤ c → c ≤ b → c = a ∨ c = b
-- WCovBy.le_and_le_iff
theorem WCovBy.le_and_le_iff (h : a ⩿ b) : a ≤ c ∧ c ≤ b ↔ c = a ∨ c = b 
Arguments: {α : Type u_1} [PartialOrder α] {a b c : α} (h : a ⩿ b)
Goal: a ≤ c ∧ c ≤ b ↔ c = a ∨ c = b
-- WCovBy.Icc_eq
theorem WCovBy.Icc_eq (h : a ⩿ b) : Icc a b = {a, b} 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α} (h : a ⩿ b)
Goal: Set.Icc a b = {a, b}
-- WCovBy.Ico_subset
theorem WCovBy.Ico_subset (h : a ⩿ b) : Ico a b ⊆ {a} 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α} (h : a ⩿ b)
Goal: Set.Ico a b ⊆ {a}
-- WCovBy.Ioc_subset
theorem WCovBy.Ioc_subset (h : a ⩿ b) : Ioc a b ⊆ {b} 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α} (h : a ⩿ b)
Goal: Set.Ioc a b ⊆ {b}
-- WCovBy.sup_eq
theorem WCovBy.sup_eq (hac : a ⩿ c) (hbc : b ⩿ c) (hab : a ≠ b) : a ⊔ b = c 
Arguments: {α : Type u_1} [SemilatticeSup α] {a b c : α} (hac : a ⩿ c) (hbc : b ⩿ c) (hab : a ≠ b)
Goal: a ⊔ b = c