ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- BoundedOrderHom.dual_symm_apply_toOrderHom
@[simps]
protected def dual :
    BoundedOrderHom α β ≃
      BoundedOrderHom αᵒᵈ
        βᵒᵈ 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [BoundedOrder α] [Preorder β] [BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ)
Goal: (BoundedOrderHom.dual.symm f).toOrderHom = OrderHom.dual.symm f.toOrderHom
-- BoundedOrderHom.dual_id
@[simp]
theorem dual_id : BoundedOrderHom.dual (BoundedOrderHom.id α) = BoundedOrderHom.id _ 
Arguments: {α : Type u_2} [Preorder α] [BoundedOrder α]
Goal: BoundedOrderHom.dual (BoundedOrderHom.id α) = BoundedOrderHom.id αᵒᵈ
-- BoundedOrderHom.dual_comp
@[simp]
theorem dual_comp (g : BoundedOrderHom β γ) (f : BoundedOrderHom α β) :
    BoundedOrderHom.dual (g.comp f) = g.dual.comp (BoundedOrderHom.dual f) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [BoundedOrder α] [Preorder β] [BoundedOrder β] [Preorder γ] [BoundedOrder γ] (g : BoundedOrderHom β γ) (f : BoundedOrderHom α β)
Goal: BoundedOrderHom.dual (g.comp f) = (BoundedOrderHom.dual g).comp (BoundedOrderHom.dual f)
-- BoundedOrderHom.symm_dual_id
@[simp]
theorem symm_dual_id : BoundedOrderHom.dual.symm (BoundedOrderHom.id _) = BoundedOrderHom.id α 
Arguments: {α : Type u_2} [Preorder α] [BoundedOrder α]
Goal: BoundedOrderHom.dual.symm (BoundedOrderHom.id αᵒᵈ) = BoundedOrderHom.id α
-- BoundedOrderHom.symm_dual_comp
@[simp]
theorem symm_dual_comp (g : BoundedOrderHom βᵒᵈ γᵒᵈ) (f : BoundedOrderHom αᵒᵈ βᵒᵈ) :
    BoundedOrderHom.dual.symm (g.comp f) =
      (BoundedOrderHom.dual.symm g).comp (BoundedOrderHom.dual.symm f) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [BoundedOrder α] [Preorder β] [BoundedOrder β] [Preorder γ] [BoundedOrder γ] (g : BoundedOrderHom βᵒᵈ γᵒᵈ) (f : BoundedOrderHom αᵒᵈ βᵒᵈ)
Goal: BoundedOrderHom.dual.symm (g.comp f) = (BoundedOrderHom.dual.symm g).comp (BoundedOrderHom.dual.symm f)
-- CompletePartialOrder.lubOfDirected
class CompletePartialOrder (α : Type*) extends PartialOrder α, SupSet α where
    lubOfDirected : ∀ d, DirectedOn (· ≤ ·) d → IsLUB d (sSup d)
Arguments: {α : Type u_4} [self : CompletePartialOrder α] (d : Set α)
Goal: DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB d (sSup d)
-- DirectedOn.isLUB_sSup
protected lemma DirectedOn.isLUB_sSup : DirectedOn (· ≤ ·) d → IsLUB d (sSup d) 
Arguments: {α : Type u_2} [CompletePartialOrder α] {d : Set α}
Goal: DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB d (sSup d)
-- DirectedOn.le_sSup
protected lemma DirectedOn.le_sSup (hd : DirectedOn (· ≤ ·) d) (ha : a ∈ d) : a ≤ sSup d 
Arguments: {α : Type u_2} [CompletePartialOrder α] {d : Set α} {a : α} (hd : DirectedOn (fun x x_1 => x ≤ x_1) d) (ha : a ∈ d)
Goal: a ≤ sSup d
-- DirectedOn.sSup_le
protected lemma DirectedOn.sSup_le (hd : DirectedOn (· ≤ ·) d) (ha : ∀ b ∈ d, b ≤ a) : sSup d ≤ a 
Arguments: {α : Type u_2} [CompletePartialOrder α] {d : Set α} {a : α} (hd : DirectedOn (fun x x_1 => x ≤ x_1) d) (ha : ∀ b ∈ d, b ≤ a)
Goal: sSup d ≤ a
-- Directed.le_iSup
protected lemma Directed.le_iSup (hf : Directed (· ≤ ·) f) (i : ι) : f i ≤ ⨆ j, f j 
Arguments: {ι : Sort u_1} {α : Type u_2} [CompletePartialOrder α] {f : ι → α} (hf : Directed (fun x x_1 => x ≤ x_1) f) (i : ι)
Goal: f i ≤ ⨆ j, f j
-- Directed.iSup_le
protected lemma Directed.iSup_le (hf : Directed (· ≤ ·) f) (ha : ∀ i, f i ≤ a) :  ⨆ i, f i ≤ a 
Arguments: {ι : Sort u_1} {α : Type u_2} [CompletePartialOrder α] {f : ι → α} {a : α} (hf : Directed (fun x x_1 => x ≤ x_1) f) (ha : ∀ (i : ι), f i ≤ a)
Goal: ⨆ i, f i ≤ a
-- CompletePartialOrder.scottContinuous
lemma CompletePartialOrder.scottContinuous {f : α → β} :
    ScottContinuous f ↔
    ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → IsLUB (f '' d) (f (sSup d)) 
Arguments: {α : Type u_2} {β : Type u_3} [CompletePartialOrder α] [Preorder β] {f : α → β}
Goal: ScottContinuous f ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
-- Set.Iic.coe_inf
@[simp, norm_cast]
protected lemma coe_inf [SemilatticeInf α] {x y : Iic a} :
    (↑(x ⊓ y) : α) = (x : α) ⊓ (y : α) 
Arguments: {α : Type u_1} {a : α} [SemilatticeInf α] {x y : ↑(Set.Iic a)}
Goal: ↑(x ⊓ y) = ↑x ⊓ ↑y
-- Set.Iic.coe_sup
@[simp, norm_cast]
protected lemma coe_sup [SemilatticeSup α] {x y : Iic a} :
    (↑(x ⊔ y) : α) = (x : α) ⊔ (y : α) 
Arguments: {α : Type u_1} {a : α} [SemilatticeSup α] {x y : ↑(Set.Iic a)}
Goal: ↑(x ⊔ y) = ↑x ⊔ ↑y
-- Set.Iic.coe_top
@[simp]
theorem coe_top [Preorder α] : (⊤ : Iic a) = a 
Arguments: {α : Type u_1} {a : α} [Preorder α]
Goal: ↑⊤ = a
-- Set.Iic.eq_top_iff
protected lemma eq_top_iff [Preorder α] {x : Iic a} :
    x = ⊤ ↔ (x : α) = a 
Arguments: {α : Type u_1} {a : α} [Preorder α] {x : ↑(Set.Iic a)}
Goal: x = ⊤ ↔ ↑x = a
-- Set.Iic.coe_bot
@[simp]
theorem coe_bot [Preorder α] [OrderBot α] : (⊥ : Iic a) = (⊥ : α) 
Arguments: {α : Type u_1} {a : α} [Preorder α] [OrderBot α]
Goal: ↑⊥ = ⊥
-- Set.Iic.disjoint_iff
protected lemma disjoint_iff [SemilatticeInf α] [OrderBot α] {x y : Iic a} :
    Disjoint x y ↔ Disjoint (x : α) (y : α) 
Arguments: {α : Type u_1} {a : α} [SemilatticeInf α] [OrderBot α] {x y : ↑(Set.Iic a)}
Goal: Disjoint x y ↔ Disjoint ↑x ↑y
-- Set.Iic.codisjoint_iff
protected lemma codisjoint_iff [SemilatticeSup α] {x y : Iic a} :
    Codisjoint x y ↔ (x : α) ⊔ (y : α) = a 
Arguments: {α : Type u_1} {a : α} [SemilatticeSup α] {x y : ↑(Set.Iic a)}
Goal: Codisjoint x y ↔ ↑x ⊔ ↑y = a
-- Set.Iic.isCompl_iff
protected lemma isCompl_iff [Lattice α] [BoundedOrder α] {x y : Iic a} :
    IsCompl x y ↔ Disjoint (x : α) (y : α) ∧ (x : α) ⊔ (y : α) = a 
Arguments: {α : Type u_1} {a : α} [Lattice α] [BoundedOrder α] {x y : ↑(Set.Iic a)}
Goal: IsCompl x y ↔ Disjoint ↑x ↑y ∧ ↑x ⊔ ↑y = a
-- Set.Ici.coe_bot
@[simp]
theorem coe_bot [Preorder α] {a : α} : ↑(⊥ : Ici a) = a 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: ↑⊥ = a
-- Set.Ici.coe_top
@[simp]
theorem coe_top [Preorder α] [OrderTop α] {a : α} : ↑(⊤ : Ici a) = (⊤ : α) 
Arguments: {α : Type u_1} [Preorder α] [OrderTop α] {a : α}
Goal: ↑⊤ = ⊤
-- MvFunctor.of_mem_supp
theorem of_mem_supp {α : TypeVec n} {x : F α} {P : ∀ ⦃i⦄, α i → Prop} (h : LiftP P x) (i : Fin2 n) :
    ∀ y ∈ supp x i, P y 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type v} [MvFunctor F] {α : TypeVec.{u} n} {x : F α} {P : ⦃i : Fin2 n⦄ → α i → Prop} (h : MvFunctor.LiftP P x) (i : Fin2 n) (y : α i)
Goal: y ∈ MvFunctor.supp x i → P y
-- LawfulMvFunctor.id_map
class LawfulMvFunctor {n : ℕ} (F : TypeVec n → Type*) [MvFunctor F] : Prop where
    id_map : ∀ {α : TypeVec n} (x : F α), TypeVec.id <$$> x = x
    comp_map :
    ∀ {α β γ : TypeVec n} (g : α ⟹ β) (h : β ⟹ γ) (x : F α), (h ⊚ g) <$$> x = h <$$> g <$$> x
Arguments: {n : ℕ} {F : TypeVec.{u_2} n → Type u_1} [MvFunctor F] [self : LawfulMvFunctor F] {α : TypeVec.{u_2} n} (x : F α)
Goal: TypeVec.id <$$> x = x
-- LawfulMvFunctor.comp_map
class LawfulMvFunctor {n : ℕ} (F : TypeVec n → Type*) [MvFunctor F] : Prop where
    id_map : ∀ {α : TypeVec n} (x : F α), TypeVec.id <$$> x = x
    comp_map :
    ∀ {α β γ : TypeVec n} (g : α ⟹ β) (h : β ⟹ γ) (x : F α), (h ⊚ g) <$$> x = h <$$> g <$$> x
Arguments: {n : ℕ} {F : TypeVec.{u_2} n → Type u_1} [MvFunctor F] [self : LawfulMvFunctor F] {α β γ : TypeVec.{u_2} n} (g : α ⟹ β) (h : β ⟹ γ) (x : F α)
Goal: (h ⊚ g) <$$> x = h <$$> g <$$> x
-- MvFunctor.id_map
@[simp]
theorem id_map (x : F α) : TypeVec.id <$$> x = x 
Arguments: {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [MvFunctor F] [LawfulMvFunctor F] (x : F α)
Goal: TypeVec.id <$$> x = x
-- MvFunctor.id_map'
@[simp]
theorem id_map' (x : F α) : (fun _i a => a) <$$> x = x 
Arguments: {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [MvFunctor F] [LawfulMvFunctor F] (x : F α)
Goal: (fun _i a => a) <$$> x = x
-- MvFunctor.map_map
theorem map_map (g : α ⟹ β) (h : β ⟹ γ) (x : F α) : h <$$> g <$$> x = (h ⊚ g) <$$> x 
Arguments: {n : ℕ} {α β γ : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [MvFunctor F] [LawfulMvFunctor F] (g : α ⟹ β) (h : β ⟹ γ) (x : F α)
Goal: h <$$> g <$$> x = (h ⊚ g) <$$> x
-- MvFunctor.exists_iff_exists_of_mono
theorem exists_iff_exists_of_mono {P : F α → Prop} {q : F β → Prop}
    (f : α ⟹ β) (g : β ⟹ α)
    (h₀ : f ⊚ g = TypeVec.id)
    (h₁ : ∀ u : F α, P u ↔ q (f <$$> u)) :
    (∃ u : F α, P u) ↔ ∃ u : F β, q u 
Arguments: {n : ℕ} {α β : TypeVec.{u} n} (F : TypeVec.{u} n → Type v) [MvFunctor F] [LawfulMvFunctor F] {P : F α → Prop} {q : F β → Prop} (f : α ⟹ β) (g : β ⟹ α) (h₀ : f ⊚ g = TypeVec.id) (h₁ : ∀ (u : F α), P u ↔ q (f <$$> u))
Goal: (∃ u, P u) ↔ ∃ u, q u
-- MvFunctor.LiftP_def
theorem LiftP_def (x : F α) : LiftP' P x ↔ ∃ u : F (Subtype_ P), subtypeVal P <$$> u = x 
Arguments: {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [MvFunctor F] (P : α ⟹ TypeVec.repeat n Prop) [LawfulMvFunctor F] (x : F α)
Goal: MvFunctor.LiftP' P x ↔ ∃ u, TypeVec.subtypeVal P <$$> u = x
-- MvFunctor.LiftR_def
theorem LiftR_def (x y : F α) :
    LiftR' R x y ↔
      ∃ u : F (Subtype_ R),
        (TypeVec.prod.fst ⊚ subtypeVal R) <$$> u = x ∧
          (TypeVec.prod.snd ⊚ subtypeVal R) <$$> u = y 
Arguments: {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [MvFunctor F] (R : α ⊗ α ⟹ TypeVec.repeat n Prop) [LawfulMvFunctor F] (x y : F α)
Goal: MvFunctor.LiftR' R x y ↔
  ∃ u, (TypeVec.prod.fst ⊚ TypeVec.subtypeVal R) <$$> u = x ∧ (TypeVec.prod.snd ⊚ TypeVec.subtypeVal R) <$$> u = y
-- MvFunctor.LiftP_PredLast_iff
theorem LiftP_PredLast_iff {β} (P : β → Prop) (x : F (α ::: β)) :
    LiftP' (PredLast' _ P) x ↔ LiftP (PredLast _ P) x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u_1} [MvFunctor F] [LawfulMvFunctor F] {α : TypeVec.{u} n} {β : Type u} (P : β → Prop) (x : F (α ::: β))
Goal: MvFunctor.LiftP' (α.PredLast' P) x ↔ MvFunctor.LiftP (α.PredLast P) x
-- MvFunctor.LiftR_RelLast_iff
theorem LiftR_RelLast_iff (x y : F (α ::: β)) :
    LiftR' (RelLast' _ rr) x y ↔ LiftR (RelLast (i := _) _ rr) x y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u_1} [MvFunctor F] [LawfulMvFunctor F] {α : TypeVec.{u} n} {β : Type u} (rr : β → β → Prop) (x y : F (α ::: β))
Goal: MvFunctor.LiftR' (α.RelLast' rr) x y ↔ MvFunctor.LiftR (fun {i} => α.RelLast rr) x y
-- IsCompactlyGenerated.BooleanGenerators.isAtom
structure BooleanGenerators (S : Set α) : Prop where
    isAtom : ∀ I ∈ S, IsAtom I
    finitelyAtomistic : ∀ (s : Finset α) (a : α),
      ↑s ⊆ S → IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id
Arguments: {α : Type u_1} [CompleteLattice α] {S : Set α} (self : IsCompactlyGenerated.BooleanGenerators S) (I : α)
Goal: I ∈ S → IsAtom I
-- IsCompactlyGenerated.BooleanGenerators.finitelyAtomistic
structure BooleanGenerators (S : Set α) : Prop where
    isAtom : ∀ I ∈ S, IsAtom I
    finitelyAtomistic : ∀ (s : Finset α) (a : α),
      ↑s ⊆ S → IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id
Arguments: {α : Type u_1} [CompleteLattice α] {S : Set α} (self : IsCompactlyGenerated.BooleanGenerators S) (s : Finset α) (a : α)
Goal: ↑s ⊆ S → CompleteLattice.IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id
-- IsCompactlyGenerated.BooleanGenerators.mono
lemma mono (hS : BooleanGenerators S) {T : Set α} (hTS : T ⊆ S) : BooleanGenerators T 
Arguments: {α : Type u_1} [CompleteLattice α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) {T : Set α} (hTS : T ⊆ S)
Goal: IsCompactlyGenerated.BooleanGenerators T
-- IsCompactlyGenerated.BooleanGenerators.atomistic
lemma atomistic (hS : BooleanGenerators S) (a : α) (ha : a ≤ sSup S) : ∃ T ⊆ S, a = sSup T 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (a : α) (ha : a ≤ sSup S)
Goal: ∃ T ⊆ S, a = sSup T
-- IsCompactlyGenerated.BooleanGenerators.isAtomistic_of_sSup_eq_top
lemma isAtomistic_of_sSup_eq_top (hS : BooleanGenerators S) (h : sSup S = ⊤) :
    IsAtomistic α 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (h : sSup S = ⊤)
Goal: IsAtomistic α
-- IsCompactlyGenerated.BooleanGenerators.mem_of_isAtom_of_le_sSup_atoms
lemma mem_of_isAtom_of_le_sSup_atoms (hS : BooleanGenerators S) (a : α) (ha : IsAtom a)
    (haS : a ≤ sSup S) : a ∈ S 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (a : α) (ha : IsAtom a) (haS : a ≤ sSup S)
Goal: a ∈ S
-- IsCompactlyGenerated.BooleanGenerators.sSup_inter
lemma sSup_inter (hS : BooleanGenerators S) {T₁ T₂ : Set α} (hT₁ : T₁ ⊆ S) (hT₂ : T₂ ⊆ S) :
    sSup (T₁ ∩ T₂) = (sSup T₁) ⊓ (sSup T₂) 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) {T₁ T₂ : Set α} (hT₁ : T₁ ⊆ S) (hT₂ : T₂ ⊆ S)
Goal: sSup (T₁ ∩ T₂) = sSup T₁ ⊓ sSup T₂
-- IsCompactlyGenerated.BooleanGenerators.complementedLattice_of_sSup_eq_top
lemma complementedLattice_of_sSup_eq_top (hS : BooleanGenerators S) (h : sSup S = ⊤) :
    ComplementedLattice α 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (h : sSup S = ⊤)
Goal: ComplementedLattice α
-- IsCompactlyGenerated.BooleanGenerators.sSup_le_sSup_iff_of_atoms
lemma sSup_le_sSup_iff_of_atoms (hS : BooleanGenerators S) (X Y : Set α) (hX : X ⊆ S) (hY : Y ⊆ S) :
    sSup X ≤ sSup Y ↔ X ⊆ Y 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (X Y : Set α) (hX : X ⊆ S) (hY : Y ⊆ S)
Goal: sSup X ≤ sSup Y ↔ X ⊆ Y
-- IsCompactlyGenerated.BooleanGenerators.eq_atoms_of_sSup_eq_top
lemma eq_atoms_of_sSup_eq_top (hS : BooleanGenerators S) (h : sSup S = ⊤) :
    S = {a : α | IsAtom a} 
Arguments: {α : Type u_1} [CompleteLattice α] [IsCompactlyGenerated α] {S : Set α} (hS : IsCompactlyGenerated.BooleanGenerators S) (h : sSup S = ⊤)
Goal: S = {a | IsAtom a}
-- isChain_empty
theorem isChain_empty : IsChain r ∅ 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: IsChain r ∅
-- Set.Subsingleton.isChain
theorem Set.Subsingleton.isChain (hs : s.Subsingleton) : IsChain r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (hs : s.Subsingleton)
Goal: IsChain r s
-- IsChain.mono
theorem IsChain.mono : s ⊆ t → IsChain r t → IsChain r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s t : Set α}
Goal: s ⊆ t → IsChain r t → IsChain r s
-- IsChain.mono_rel
theorem IsChain.mono_rel {r' : α → α → Prop} (h : IsChain r s) (h_imp : ∀ x y, r x y → r' x y) :
    IsChain r' s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} {r' : α → α → Prop} (h : IsChain r s) (h_imp : ∀ (x y : α), r x y → r' x y)
Goal: IsChain r' s
-- IsChain.symm
theorem IsChain.symm (h : IsChain r s) : IsChain (flip r) s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (h : IsChain r s)
Goal: IsChain (flip r) s
-- isChain_of_trichotomous
theorem isChain_of_trichotomous [IsTrichotomous α r] (s : Set α) : IsChain r s 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsTrichotomous α r] (s : Set α)
Goal: IsChain r s
-- IsChain.insert
protected theorem IsChain.insert (hs : IsChain r s) (ha : ∀ b ∈ s, a ≠ b → a ≺ b ∨ b ≺ a) :
    IsChain r (insert a s) 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α} (hs : IsChain r s) (ha : ∀ b ∈ s, a ≠ b → r a b ∨ r b a)
Goal: IsChain r (insert a s)
-- isChain_univ_iff
theorem isChain_univ_iff : IsChain r (univ : Set α) ↔ IsTrichotomous α r 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: IsChain r Set.univ ↔ IsTrichotomous α r
-- IsChain.image
theorem IsChain.image (r : α → α → Prop) (s : β → β → Prop) (f : α → β)
    (h : ∀ x y, r x y → s (f x) (f y)) {c : Set α} (hrc : IsChain r c) : IsChain s (f '' c) 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) (f : α → β) (h : ∀ (x y : α), r x y → s (f x) (f y)) {c : Set α} (hrc : IsChain r c)
Goal: IsChain s (f '' c)
-- Monotone.isChain_range
theorem Monotone.isChain_range [LinearOrder α] [Preorder β] {f : α → β} (hf : Monotone f) :
    IsChain (· ≤ ·) (range f) 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder α] [Preorder β] {f : α → β} (hf : Monotone f)
Goal: IsChain (fun x x_1 => x ≤ x_1) (Set.range f)
-- IsChain.lt_of_le
theorem IsChain.lt_of_le [PartialOrder α] {s : Set α} (h : IsChain (· ≤ ·) s) :
    IsChain (· < ·) s 
Arguments: {α : Type u_1} [PartialOrder α] {s : Set α} (h : IsChain (fun x x_1 => x ≤ x_1) s)
Goal: IsChain (fun x x_1 => x < x_1) s
-- IsChain.total
theorem IsChain.total (h : IsChain r s) (hx : x ∈ s) (hy : y ∈ s) : x ≺ y ∨ y ≺ x 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} {x y : α} [IsRefl α r] (h : IsChain r s) (hx : x ∈ s) (hy : y ∈ s)
Goal: r x y ∨ r y x
-- IsChain.directedOn
theorem IsChain.directedOn (H : IsChain r s) : DirectedOn r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} [IsRefl α r] (H : IsChain r s)
Goal: DirectedOn r s
-- IsChain.directed
protected theorem IsChain.directed {f : β → α} {c : Set β} (h : IsChain (f ⁻¹'o r) c) :
    Directed r fun x : { a : β // a ∈ c } => f x 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} [IsRefl α r] {f : β → α} {c : Set β} (h : IsChain (f ⁻¹'o r) c)
Goal: Directed r fun x => f ↑x
-- IsChain.exists3
theorem IsChain.exists3 (hchain : IsChain r s) [IsTrans α r] {a b c} (mem1 : a ∈ s) (mem2 : b ∈ s)
    (mem3 : c ∈ s) : ∃ (z : _) (_ : z ∈ s), r a z ∧ r b z ∧ r c z 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} [IsRefl α r] (hchain : IsChain r s) [IsTrans α r] {a b c : α} (mem1 : a ∈ s) (mem2 : b ∈ s) (mem3 : c ∈ s)
Goal: ∃ z, ∃ (_ : z ∈ s), r a z ∧ r b z ∧ r c z
-- IsMaxChain.isChain
theorem IsMaxChain.isChain (h : IsMaxChain r s) : IsChain r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (h : IsMaxChain r s)
Goal: IsChain r s
-- IsMaxChain.not_superChain
theorem IsMaxChain.not_superChain (h : IsMaxChain r s) : ¬SuperChain r s t 
Arguments: {α : Type u_1} {r : α → α → Prop} {s t : Set α} (h : IsMaxChain r s)
Goal: ¬SuperChain r s t
-- IsMaxChain.bot_mem
theorem IsMaxChain.bot_mem [LE α] [OrderBot α] (h : IsMaxChain (· ≤ ·) s) : ⊥ ∈ s 
Arguments: {α : Type u_1} {s : Set α} [LE α] [OrderBot α] (h : IsMaxChain (fun x x_1 => x ≤ x_1) s)
Goal: ⊥ ∈ s
-- IsMaxChain.top_mem
theorem IsMaxChain.top_mem [LE α] [OrderTop α] (h : IsMaxChain (· ≤ ·) s) : ⊤ ∈ s 
Arguments: {α : Type u_1} {s : Set α} [LE α] [OrderTop α] (h : IsMaxChain (fun x x_1 => x ≤ x_1) s)
Goal: ⊤ ∈ s
-- succChain_spec
theorem succChain_spec (h : ∃ t, IsChain r s ∧ SuperChain r s t) :
    SuperChain r s (SuccChain r s) 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (h : ∃ t, IsChain r s ∧ SuperChain r s t)
Goal: SuperChain r s (SuccChain r s)
-- IsChain.succ
theorem IsChain.succ (hs : IsChain r s) : IsChain r (SuccChain r s) 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (hs : IsChain r s)
Goal: IsChain r (SuccChain r s)
-- IsChain.superChain_succChain
theorem IsChain.superChain_succChain (hs₁ : IsChain r s) (hs₂ : ¬IsMaxChain r s) :
    SuperChain r s (SuccChain r s) 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α} (hs₁ : IsChain r s) (hs₂ : ¬IsMaxChain r s)
Goal: SuperChain r s (SuccChain r s)
-- subset_succChain
theorem subset_succChain : s ⊆ SuccChain r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Set α}
Goal: s ⊆ SuccChain r s
-- chainClosure_empty
theorem chainClosure_empty : ChainClosure r ∅ 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: ChainClosure r ∅
-- chainClosure_maxChain
theorem chainClosure_maxChain : ChainClosure r (maxChain r) 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: ChainClosure r (maxChain r)
-- _private.Mathlib.Order.Chain.0.chainClosure_succ_total_aux
private theorem chainClosure_succ_total_aux (hc₁ : ChainClosure r c₁)
    (h : ∀ ⦃c₃⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂) :
    SuccChain r c₂ ⊆ c₁ ∨ c₁ ⊆ c₂ 
Arguments: {α : Type u_1} {r : α → α → Prop} {c₁ c₂ : Set α} (hc₁ : ChainClosure r c₁) (h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂)
Goal: SuccChain r c₂ ⊆ c₁ ∨ c₁ ⊆ c₂
-- _private.Mathlib.Order.Chain.0.chainClosure_succ_total
private theorem chainClosure_succ_total (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂)
    (h : c₁ ⊆ c₂) : c₂ = c₁ ∨ SuccChain r c₁ ⊆ c₂ 
Arguments: {α : Type u_1} {r : α → α → Prop} {c₁ c₂ : Set α} (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂) (h : c₁ ⊆ c₂)
Goal: c₂ = c₁ ∨ SuccChain r c₁ ⊆ c₂
-- ChainClosure.total
theorem ChainClosure.total (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂) :
    c₁ ⊆ c₂ ∨ c₂ ⊆ c₁ 
Arguments: {α : Type u_1} {r : α → α → Prop} {c₁ c₂ : Set α} (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂)
Goal: c₁ ⊆ c₂ ∨ c₂ ⊆ c₁
-- ChainClosure.succ_fixpoint
theorem ChainClosure.succ_fixpoint (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂)
    (hc : SuccChain r c₂ = c₂) : c₁ ⊆ c₂ 
Arguments: {α : Type u_1} {r : α → α → Prop} {c₁ c₂ : Set α} (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂) (hc : SuccChain r c₂ = c₂)
Goal: c₁ ⊆ c₂
-- ChainClosure.succ_fixpoint_iff
theorem ChainClosure.succ_fixpoint_iff (hc : ChainClosure r c) :
    SuccChain r c = c ↔ c = maxChain r 
Arguments: {α : Type u_1} {r : α → α → Prop} {c : Set α} (hc : ChainClosure r c)
Goal: SuccChain r c = c ↔ c = maxChain r
-- ChainClosure.isChain
theorem ChainClosure.isChain (hc : ChainClosure r c) : IsChain r c 
Arguments: {α : Type u_1} {r : α → α → Prop} {c : Set α} (hc : ChainClosure r c)
Goal: IsChain r c
-- maxChain_spec
theorem maxChain_spec : IsMaxChain r (maxChain r) 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: IsMaxChain r (maxChain r)
-- Flag.Chain'
structure Flag (α : Type*) [LE α] where
    carrier : Set α
    Chain' : IsChain (· ≤ ·) carrier
    max_chain' : ∀ ⦃s⦄, IsChain (· ≤ ·) s → carrier ⊆ s → carrier = s
Arguments: {α : Type u_3} [LE α] (self : Flag α)
Goal: IsChain (fun x x_1 => x ≤ x_1) self.carrier
-- Flag.max_chain'
structure Flag (α : Type*) [LE α] where
    carrier : Set α
    Chain' : IsChain (· ≤ ·) carrier
    max_chain' : ∀ ⦃s⦄, IsChain (· ≤ ·) s → carrier ⊆ s → carrier = s
Arguments: {α : Type u_3} [LE α] (self : Flag α) ⦃s : Set α⦄
Goal: IsChain (fun x x_1 => x ≤ x_1) s → self.carrier ⊆ s → self.carrier = s
-- Flag.ext
@[ext]
theorem ext : (s : Set α) = t → s = t 
Arguments: {α : Type u_1} [LE α] {s t : Flag α}
Goal: ↑s = ↑t → s = t
-- Flag.mem_coe_iff
theorem mem_coe_iff : a ∈ (s : Set α) ↔ a ∈ s 
Arguments: {α : Type u_1} [LE α] {s : Flag α} {a : α}
Goal: a ∈ ↑s ↔ a ∈ s
-- Flag.coe_mk
@[simp]
theorem coe_mk (s : Set α) (h₁ h₂) : (mk s h₁ h₂ : Set α) = s 
Arguments: {α : Type u_1} [LE α] (s : Set α) (h₁ : IsChain (fun x x_1 => x ≤ x_1) s) (h₂ : ∀ ⦃s_1 : Set α⦄, IsChain (fun x x_1 => x ≤ x_1) s_1 → s ⊆ s_1 → s = s_1)
Goal: ↑{ carrier := s, Chain' := h₁, max_chain' := h₂ } = s
-- Flag.mk_coe
@[simp]
theorem mk_coe (s : Flag α) : mk (s : Set α) s.Chain' s.max_chain' = s 
Arguments: {α : Type u_1} [LE α] (s : Flag α)
Goal: { carrier := ↑s, Chain' := ⋯, max_chain' := ⋯ } = s
-- Flag.chain_le
theorem chain_le (s : Flag α) : IsChain (· ≤ ·) (s : Set α) 
Arguments: {α : Type u_1} [LE α] (s : Flag α)
Goal: IsChain (fun x x_1 => x ≤ x_1) ↑s
-- Flag.maxChain
protected theorem maxChain (s : Flag α) : IsMaxChain (· ≤ ·) (s : Set α) 
Arguments: {α : Type u_1} [LE α] (s : Flag α)
Goal: IsMaxChain (fun x x_1 => x ≤ x_1) ↑s
-- Flag.top_mem
theorem top_mem [OrderTop α] (s : Flag α) : (⊤ : α) ∈ s 
Arguments: {α : Type u_1} [LE α] [OrderTop α] (s : Flag α)
Goal: ⊤ ∈ s
-- Flag.bot_mem
theorem bot_mem [OrderBot α] (s : Flag α) : (⊥ : α) ∈ s 
Arguments: {α : Type u_1} [LE α] [OrderBot α] (s : Flag α)
Goal: ⊥ ∈ s
-- Flag.le_or_le
protected theorem le_or_le (s : Flag α) (ha : a ∈ s) (hb : b ∈ s) : a ≤ b ∨ b ≤ a 
Arguments: {α : Type u_1} [Preorder α] {a b : α} (s : Flag α) (ha : a ∈ s) (hb : b ∈ s)
Goal: a ≤ b ∨ b ≤ a
-- Flag.chain_lt
theorem chain_lt (s : Flag α) : IsChain (· < ·) (s : Set α) 
Arguments: {α : Type u_1} [PartialOrder α] (s : Flag α)
Goal: IsChain (fun x x_1 => x < x_1) ↑s
-- Filter.mem_cofinite
@[simp]
theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite 
Arguments: {α : Type u_2} {s : Set α}
Goal: s ∈ Filter.cofinite ↔ sᶜ.Finite
-- Filter.eventually_cofinite
@[simp]
theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔ { x | ¬p x }.Finite 
Arguments: {α : Type u_2} {p : α → Prop}
Goal: (∀ᶠ (x : α) in Filter.cofinite, p x) ↔ {x | ¬p x}.Finite