ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- WellFounded.exists_well_order_ge
theorem exists_well_order_ge : ∃ s, r ≤ s ∧ IsWellOrder α s 
Arguments: {α : Type u} {r : α → α → Prop} (hwf : WellFounded r)
Goal: ∃ s, r ≤ s ∧ IsWellOrder α s
-- toWellOrderExtension_strictMono
theorem toWellOrderExtension_strictMono [Preorder α] [WellFoundedLT α] :
    StrictMono (toWellOrderExtension : α → WellOrderExtension α) 
Arguments: {α : Type u} [Preorder α] [WellFoundedLT α]
Goal: StrictMono ⇑toWellOrderExtension
-- ClosureOperator.idempotent'
structure ClosureOperator [Preorder α] extends α →o α where
    le_closure' : ∀ x, x ≤ toFun x
    idempotent' : ∀ x, toFun (toFun x) = toFun x
    IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
Arguments: {α : Type u_1} [Preorder α] (self : ClosureOperator α) (x : α)
Goal: self.toFun (self.toFun x) = self.toFun x
-- ClosureOperator.isClosed_iff
structure ClosureOperator [Preorder α] extends α →o α where
    le_closure' : ∀ x, x ≤ toFun x
    idempotent' : ∀ x, toFun (toFun x) = toFun x
    IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
Arguments: {α : Type u_1} [Preorder α] (self : ClosureOperator α) {x : α}
Goal: self.IsClosed x ↔ self.toFun x = x
-- ClosureOperator.le_closure'
structure ClosureOperator [Preorder α] extends α →o α where
    le_closure' : ∀ x, x ≤ toFun x
    idempotent' : ∀ x, toFun (toFun x) = toFun x
    IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
Arguments: {α : Type u_1} [Preorder α] (self : ClosureOperator α) (x : α)
Goal: x ≤ self.toFun x
-- ClosureOperator.conjBy_apply
@[simps apply]
def conjBy {α β} [Preorder α] [Preorder β] (c : ClosureOperator α)
    (e : α ≃o β) : ClosureOperator β 
Arguments: {α : Type u_4} {β : Type u_5} [Preorder α] [Preorder β] (c : ClosureOperator α) (e : α ≃o β) (a : β)
Goal: (c.conjBy e) a = (e.conj ↑c) a
-- ClosureOperator.conjBy_refl
lemma conjBy_refl {α} [Preorder α] (c : ClosureOperator α) :
    c.conjBy (OrderIso.refl α) = c 
Arguments: {α : Type u_4} [Preorder α] (c : ClosureOperator α)
Goal: c.conjBy (OrderIso.refl α) = c
-- ClosureOperator.conjBy_trans
lemma conjBy_trans {α β γ} [Preorder α] [Preorder β] [Preorder γ]
    (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : ClosureOperator α) :
    c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂ 
Arguments: {α : Type u_4} {β : Type u_5} {γ : Type u_6} [Preorder α] [Preorder β] [Preorder γ] (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : ClosureOperator α)
Goal: c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂
-- ClosureOperator.id_isClosed
@[simps!]
def id : ClosureOperator α 
Arguments: (α : Type u_1) [PartialOrder α]
Goal: ∀ (x : α), (ClosureOperator.id α).IsClosed x = True
-- ClosureOperator.id_apply
@[simps!]
def id : ClosureOperator α 
Arguments: (α : Type u_1) [PartialOrder α] (a : α)
Goal: (ClosureOperator.id α) a = a
-- ClosureOperator.ext
@[ext]
theorem ext : ∀ c₁ c₂ : ClosureOperator α, (∀ x, c₁ x = c₂ x) → c₁ = c₂ 
Arguments: {α : Type u_1} [PartialOrder α] (c₁ c₂ : ClosureOperator α)
Goal: (∀ (x : α), c₁ x = c₂ x) → c₁ = c₂
-- ClosureOperator.mk'_isClosed
@[simps]
def mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
    ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ (x : α), x ≤ f x) (hf₃ : ∀ (x : α), f (f x) ≤ f x) (x : α)
Goal: (ClosureOperator.mk' f hf₁ hf₂ hf₃).IsClosed x = (f x = x)
-- ClosureOperator.mk'_apply
@[simps]
def mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
    ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ (x : α), x ≤ f x) (hf₃ : ∀ (x : α), f (f x) ≤ f x)
Goal: ∀ (a : α), (ClosureOperator.mk' f hf₁ hf₂ hf₃) a = f a
-- ClosureOperator.mk₂_apply
@[simps]
def mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
    ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (hf : ∀ (x : α), x ≤ f x) (hmin : ∀ ⦃x y : α⦄, x ≤ f y → f x ≤ f y)
Goal: ∀ (a : α), (ClosureOperator.mk₂ f hf hmin) a = f a
-- ClosureOperator.mk₂_isClosed
@[simps]
def mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
    ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (hf : ∀ (x : α), x ≤ f x) (hmin : ∀ ⦃x y : α⦄, x ≤ f y → f x ≤ f y) (x : α)
Goal: (ClosureOperator.mk₂ f hf hmin).IsClosed x = (f x = x)
-- ClosureOperator.ofPred_isClosed
@[simps!]
def ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
    (hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (p : α → Prop) (hf : ∀ (x : α), x ≤ f x) (hfp : ∀ (x : α), p (f x)) (hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y)
Goal: ∀ (a : α), (ClosureOperator.ofPred f p hf hfp hmin).IsClosed a = p a
-- ClosureOperator.ofPred_apply
@[simps!]
def ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
    (hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α 
Arguments: {α : Type u_1} [PartialOrder α] (f : α → α) (p : α → Prop) (hf : ∀ (x : α), x ≤ f x) (hfp : ∀ (x : α), p (f x)) (hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y)
Goal: ∀ (a : α), (ClosureOperator.ofPred f p hf hfp hmin) a = f a
-- ClosureOperator.monotone
@[mono]
theorem monotone : Monotone c 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α)
Goal: Monotone ⇑c
-- ClosureOperator.le_closure
theorem le_closure (x : α) : x ≤ c x 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α)
Goal: x ≤ c x
-- ClosureOperator.idempotent
@[simp]
theorem idempotent (x : α) : c (c x) = c x 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α)
Goal: c (c x) = c x
-- ClosureOperator.isClosed_closure
@[simp] lemma isClosed_closure (x : α) : c.IsClosed (c x) 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α)
Goal: c.IsClosed (c x)
-- ClosureOperator.IsClosed.closure_eq
theorem IsClosed.closure_eq : c.IsClosed x → c x = x 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} {x : α}
Goal: c.IsClosed x → c x = x
-- ClosureOperator.isClosed_iff_closure_le
theorem isClosed_iff_closure_le : c.IsClosed x ↔ c x ≤ x 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} {x : α}
Goal: c.IsClosed x ↔ c x ≤ x
-- ClosureOperator.setOf_isClosed_eq_range_closure
theorem setOf_isClosed_eq_range_closure : {x | c.IsClosed x} = Set.range c 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α}
Goal: {x | c.IsClosed x} = Set.range ⇑c
-- ClosureOperator.le_closure_iff
theorem le_closure_iff : x ≤ c y ↔ c x ≤ c y 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} {x y : α}
Goal: x ≤ c y ↔ c x ≤ c y
-- ClosureOperator.IsClosed.closure_le_iff
@[simp]
theorem IsClosed.closure_le_iff (hy : c.IsClosed y) : c x ≤ y ↔ x ≤ y 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} {x y : α} (hy : c.IsClosed y)
Goal: c x ≤ y ↔ x ≤ y
-- ClosureOperator.closure_min
lemma closure_min (hxy : x ≤ y) (hy : c.IsClosed y) : c x ≤ y 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} {x y : α} (hxy : x ≤ y) (hy : c.IsClosed y)
Goal: c x ≤ y
-- ClosureOperator.closure_isGLB
lemma closure_isGLB (x : α) : IsGLB { y | x ≤ y ∧ c.IsClosed y } (c x) 
Arguments: {α : Type u_1} [PartialOrder α] {c : ClosureOperator α} (x : α)
Goal: IsGLB {y | x ≤ y ∧ c.IsClosed y} (c x)
-- ClosureOperator.ext_isClosed
theorem ext_isClosed (c₁ c₂ : ClosureOperator α)
    (h : ∀ x, c₁.IsClosed x ↔ c₂.IsClosed x) : c₁ = c₂ 
Arguments: {α : Type u_1} [PartialOrder α] (c₁ c₂ : ClosureOperator α) (h : ∀ (x : α), c₁.IsClosed x ↔ c₂.IsClosed x)
Goal: c₁ = c₂
-- ClosureOperator.eq_ofPred_closed
theorem eq_ofPred_closed (c : ClosureOperator α) :
    c = ofPred c c.IsClosed c.le_closure c.isClosed_closure fun x y ↦ closure_min 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α)
Goal: c = ClosureOperator.ofPred (⇑c) c.IsClosed ⋯ ⋯ ⋯
-- ClosureOperator.closure_top
@[simp]
theorem closure_top : c ⊤ = ⊤ 
Arguments: {α : Type u_1} [PartialOrder α] [OrderTop α] (c : ClosureOperator α)
Goal: c ⊤ = ⊤
-- ClosureOperator.isClosed_top
@[simp] lemma isClosed_top : c.IsClosed ⊤ 
Arguments: {α : Type u_1} [PartialOrder α] [OrderTop α] (c : ClosureOperator α)
Goal: c.IsClosed ⊤
-- ClosureOperator.closure_inf_le
theorem closure_inf_le [SemilatticeInf α] (c : ClosureOperator α) (x y : α) :
    c (x ⊓ y) ≤ c x ⊓ c y 
Arguments: {α : Type u_1} [SemilatticeInf α] (c : ClosureOperator α) (x y : α)
Goal: c (x ⊓ y) ≤ c x ⊓ c y
-- ClosureOperator.closure_sup_closure_le
theorem closure_sup_closure_le (x y : α) : c x ⊔ c y ≤ c (x ⊔ y) 
Arguments: {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x y : α)
Goal: c x ⊔ c y ≤ c (x ⊔ y)
-- ClosureOperator.closure_sup_closure_left
theorem closure_sup_closure_left (x y : α) : c (c x ⊔ y) = c (x ⊔ y) 
Arguments: {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x y : α)
Goal: c (c x ⊔ y) = c (x ⊔ y)
-- ClosureOperator.closure_sup_closure_right
theorem closure_sup_closure_right (x y : α) : c (x ⊔ c y) = c (x ⊔ y) 
Arguments: {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x y : α)
Goal: c (x ⊔ c y) = c (x ⊔ y)
-- ClosureOperator.closure_sup_closure
theorem closure_sup_closure (x y : α) : c (c x ⊔ c y) = c (x ⊔ y) 
Arguments: {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x y : α)
Goal: c (c x ⊔ c y) = c (x ⊔ y)
-- ClosureOperator.ofCompletePred_isClosed
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α 
Arguments: {α : Type u_1} [CompleteLattice α] (p : α → Prop) (hsinf : ∀ (s : Set α), (∀ a ∈ s, p a) → p (sInf s))
Goal: ∀ (a : α), (ClosureOperator.ofCompletePred p hsinf).IsClosed a = p a
-- ClosureOperator.ofCompletePred_apply
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α 
Arguments: {α : Type u_1} [CompleteLattice α] (p : α → Prop) (hsinf : ∀ (s : Set α), (∀ a ∈ s, p a) → p (sInf s)) (a : α)
Goal: (ClosureOperator.ofCompletePred p hsinf) a = ⨅ b, ↑b
-- ClosureOperator.sInf_isClosed
theorem sInf_isClosed {c : ClosureOperator α} {S : Set α}
    (H : ∀ x ∈ S, c.IsClosed x) : c.IsClosed (sInf S) 
Arguments: {α : Type u_1} [CompleteLattice α] {c : ClosureOperator α} {S : Set α} (H : ∀ x ∈ S, c.IsClosed x)
Goal: c.IsClosed (sInf S)
-- ClosureOperator.closure_iSup_closure
@[simp]
theorem closure_iSup_closure (f : ι → α) : c (⨆ i, c (f i)) = c (⨆ i, f i) 
Arguments: {α : Type u_1} {ι : Sort u_2} [CompleteLattice α] (c : ClosureOperator α) (f : ι → α)
Goal: c (⨆ i, c (f i)) = c (⨆ i, f i)
-- ClosureOperator.closure_iSup₂_closure
@[simp]
theorem closure_iSup₂_closure (f : ∀ i, κ i → α) :
    c (⨆ (i) (j), c (f i j)) = c (⨆ (i) (j), f i j) 
Arguments: {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} [CompleteLattice α] (c : ClosureOperator α) (f : (i : ι) → κ i → α)
Goal: c (⨆ i, ⨆ j, c (f i j)) = c (⨆ i, ⨆ j, f i j)
-- OrderIso.equivClosureOperator_apply
@[simps apply symm_apply]
def OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
    ClosureOperator α ≃ ClosureOperator β 
Arguments: {α : Type u_4} {β : Type u_5} [Preorder α] [Preorder β] (e : α ≃o β) (c : ClosureOperator α)
Goal: e.equivClosureOperator c = c.conjBy e
-- OrderIso.equivClosureOperator_symm_apply
@[simps apply symm_apply]
def OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
    ClosureOperator α ≃ ClosureOperator β 
Arguments: {α : Type u_4} {β : Type u_5} [Preorder α] [Preorder β] (e : α ≃o β) (c : ClosureOperator β)
Goal: e.equivClosureOperator.symm c = c.conjBy e.symm
-- LowerAdjoint.gc'
structure LowerAdjoint [Preorder α] [Preorder β] (u : β → α) where
    toFun : α → β
    gc' : GaloisConnection toFun u
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (self : LowerAdjoint u)
Goal: GaloisConnection self.toFun u
-- LowerAdjoint.id_toFun
@[simps]
protected def id [Preorder α] : LowerAdjoint (id : α → α) 
Arguments: (α : Type u_1) [Preorder α] (x : α)
Goal: (LowerAdjoint.id α).toFun x = x
-- LowerAdjoint.gc
theorem gc : GaloisConnection l u 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u)
Goal: GaloisConnection l.toFun u
-- LowerAdjoint.ext
@[ext]
theorem ext : ∀ l₁ l₂ : LowerAdjoint u, (l₁ : α → β) = (l₂ : α → β) → l₁ = l₂
  
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l₁ l₂ : LowerAdjoint u)
Goal: l₁.toFun = l₂.toFun → l₁ = l₂
-- LowerAdjoint.monotone
@[mono]
theorem monotone : Monotone (u ∘ l) 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u)
Goal: Monotone (u ∘ l.toFun)
-- LowerAdjoint.le_closure
theorem le_closure (x : α) : x ≤ u (l x) 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: x ≤ u (l.toFun x)
-- LowerAdjoint.closureOperator_isClosed
@[simps]
def closureOperator : ClosureOperator α 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: l.closureOperator.IsClosed x = (u (l.toFun x) = x)
-- LowerAdjoint.closureOperator_apply
@[simps]
def closureOperator : ClosureOperator α 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: l.closureOperator x = u (l.toFun x)
-- LowerAdjoint.idempotent
theorem idempotent (x : α) : u (l (u (l x))) = u (l x) 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: u (l.toFun (u (l.toFun x))) = u (l.toFun x)
-- LowerAdjoint.le_closure_iff
theorem le_closure_iff (x y : α) : x ≤ u (l y) ↔ u (l x) ≤ u (l y) 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: x ≤ u (l.toFun y) ↔ u (l.toFun x) ≤ u (l.toFun y)
-- LowerAdjoint.mem_closed_iff
theorem mem_closed_iff (x : α) : x ∈ l.closed ↔ u (l x) = x 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: x ∈ l.closed ↔ u (l.toFun x) = x
-- LowerAdjoint.closure_eq_self_of_mem_closed
theorem closure_eq_self_of_mem_closed {x : α} (h : x ∈ l.closed) : u (l x) = x 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) {x : α} (h : x ∈ l.closed)
Goal: u (l.toFun x) = x
-- LowerAdjoint.mem_closed_iff_closure_le
theorem mem_closed_iff_closure_le (x : α) : x ∈ l.closed ↔ u (l x) ≤ x 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: x ∈ l.closed ↔ u (l.toFun x) ≤ x
-- LowerAdjoint.closure_is_closed
@[simp, nolint simpNF] -- Porting note: lemma does prove itself, seems to be a linter error
theorem closure_is_closed (x : α) : u (l x) ∈ l.closed 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α)
Goal: u (l.toFun x) ∈ l.closed
-- LowerAdjoint.closed_eq_range_close
theorem closed_eq_range_close : l.closed = Set.range (u ∘ l) 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u)
Goal: l.closed = Set.range (u ∘ l.toFun)
-- LowerAdjoint.closure_le_closed_iff_le
@[simp]
theorem closure_le_closed_iff_le (x : α) {y : α} (hy : l.closed y) : u (l x) ≤ y ↔ x ≤ y 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α) {y : α} (hy : l.closed y)
Goal: u (l.toFun x) ≤ y ↔ x ≤ y
-- LowerAdjoint.closure_top
theorem closure_top [PartialOrder α] [OrderTop α] [Preorder β] {u : β → α} (l : LowerAdjoint u) :
    u (l ⊤) = ⊤ 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [OrderTop α] [Preorder β] {u : β → α} (l : LowerAdjoint u)
Goal: u (l.toFun ⊤) = ⊤
-- LowerAdjoint.closure_inf_le
theorem closure_inf_le [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α) :
    u (l (x ⊓ y)) ≤ u (l x) ⊓ u (l y) 
Arguments: {α : Type u_1} {β : Type u_4} [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: u (l.toFun (x ⊓ y)) ≤ u (l.toFun x) ⊓ u (l.toFun y)
-- LowerAdjoint.closure_sup_closure_le
theorem closure_sup_closure_le (x y : α) : u (l x) ⊔ u (l y) ≤ u (l (x ⊔ y)) 
Arguments: {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: u (l.toFun x) ⊔ u (l.toFun y) ≤ u (l.toFun (x ⊔ y))
-- LowerAdjoint.closure_sup_closure_left
theorem closure_sup_closure_left (x y : α) : u (l (u (l x) ⊔ y)) = u (l (x ⊔ y)) 
Arguments: {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: u (l.toFun (u (l.toFun x) ⊔ y)) = u (l.toFun (x ⊔ y))
-- LowerAdjoint.closure_sup_closure_right
theorem closure_sup_closure_right (x y : α) : u (l (x ⊔ u (l y))) = u (l (x ⊔ y)) 
Arguments: {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: u (l.toFun (x ⊔ u (l.toFun y))) = u (l.toFun (x ⊔ y))
-- LowerAdjoint.closure_sup_closure
theorem closure_sup_closure (x y : α) : u (l (u (l x) ⊔ u (l y))) = u (l (x ⊔ y)) 
Arguments: {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α)
Goal: u (l.toFun (u (l.toFun x) ⊔ u (l.toFun y))) = u (l.toFun (x ⊔ y))
-- LowerAdjoint.closure_iSup_closure
theorem closure_iSup_closure (f : ι → α) : u (l (⨆ i, u (l (f i)))) = u (l (⨆ i, f i)) 
Arguments: {α : Type u_1} {ι : Sort u_2} {β : Type u_4} [CompleteLattice α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (f : ι → α)
Goal: u (l.toFun (⨆ i, u (l.toFun (f i)))) = u (l.toFun (⨆ i, f i))
-- LowerAdjoint.closure_iSup₂_closure
theorem closure_iSup₂_closure (f : ∀ i, κ i → α) :
    u (l <| ⨆ (i) (j), u (l <| f i j)) = u (l <| ⨆ (i) (j), f i j) 
Arguments: {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {β : Type u_4} [CompleteLattice α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (f : (i : ι) → κ i → α)
Goal: u (l.toFun (⨆ i, ⨆ j, u (l.toFun (f i j)))) = u (l.toFun (⨆ i, ⨆ j, f i j))
-- LowerAdjoint.subset_closure
theorem subset_closure (s : Set β) : s ⊆ l s 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β)
Goal: s ⊆ ↑(l.toFun s)
-- LowerAdjoint.not_mem_of_not_mem_closure
theorem not_mem_of_not_mem_closure {s : Set β} {P : β} (hP : P ∉ l s) : P ∉ s 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) {s : Set β} {P : β} (hP : P ∉ l.toFun s)
Goal: P ∉ s
-- LowerAdjoint.le_iff_subset
theorem le_iff_subset (s : Set β) (S : α) : l s ≤ S ↔ s ⊆ S 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β) (S : α)
Goal: l.toFun s ≤ S ↔ s ⊆ ↑S
-- LowerAdjoint.mem_iff
theorem mem_iff (s : Set β) (x : β) : x ∈ l s ↔ ∀ S : α, s ⊆ S → x ∈ S 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β) (x : β)
Goal: x ∈ l.toFun s ↔ ∀ (S : α), s ⊆ ↑S → x ∈ S
-- LowerAdjoint.eq_of_le
theorem eq_of_le {s : Set β} {S : α} (h₁ : s ⊆ S) (h₂ : S ≤ l s) : l s = S 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) {s : Set β} {S : α} (h₁ : s ⊆ ↑S) (h₂ : S ≤ l.toFun s)
Goal: l.toFun s = S
-- LowerAdjoint.closure_union_closure_subset
theorem closure_union_closure_subset (x y : α) : (l x : Set β) ∪ l y ⊆ l (x ∪ y) 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x y : α)
Goal: ↑(l.toFun ↑x) ∪ ↑(l.toFun ↑y) ⊆ ↑(l.toFun (↑x ∪ ↑y))
-- LowerAdjoint.closure_union_closure_left
@[simp]
theorem closure_union_closure_left (x y : α) : l (l x ∪ y) = l (x ∪ y) 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x y : α)
Goal: l.toFun (↑(l.toFun ↑x) ∪ ↑y) = l.toFun (↑x ∪ ↑y)
-- LowerAdjoint.closure_union_closure_right
@[simp]
theorem closure_union_closure_right (x y : α) : l (x ∪ l y) = l (x ∪ y) 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x y : α)
Goal: l.toFun (↑x ∪ ↑(l.toFun ↑y)) = l.toFun (↑x ∪ ↑y)
-- LowerAdjoint.closure_union_closure
theorem closure_union_closure (x y : α) : l (l x ∪ l y) = l (x ∪ y) 
Arguments: {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x y : α)
Goal: l.toFun (↑(l.toFun ↑x) ∪ ↑(l.toFun ↑y)) = l.toFun (↑x ∪ ↑y)
-- LowerAdjoint.closure_iUnion_closure
@[simp]
theorem closure_iUnion_closure (f : ι → α) : l (⋃ i, l (f i)) = l (⋃ i, f i) 
Arguments: {α : Type u_1} {ι : Sort u_2} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (f : ι → α)
Goal: l.toFun (⋃ i, ↑(l.toFun ↑(f i))) = l.toFun (⋃ i, ↑(f i))
-- LowerAdjoint.closure_iUnion₂_closure
@[simp]
theorem closure_iUnion₂_closure (f : ∀ i, κ i → α) :
    l (⋃ (i) (j), l (f i j)) = l (⋃ (i) (j), f i j) 
Arguments: {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (f : (i : ι) → κ i → α)
Goal: l.toFun (⋃ i, ⋃ j, ↑(l.toFun ↑(f i j))) = l.toFun (⋃ i, ⋃ j, ↑(f i j))
-- GaloisConnection.lowerAdjoint_toFun
@[simps]
def GaloisConnection.lowerAdjoint [Preorder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : LowerAdjoint u 
Arguments: {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u)
Goal: ∀ (a : α), gc.lowerAdjoint.toFun a = l a
-- GaloisConnection.closureOperator_isClosed
@[simps!]
def GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : ClosureOperator α 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) (x : α)
Goal: gc.closureOperator.IsClosed x = (u (l x) = x)
-- GaloisConnection.closureOperator_apply
@[simps!]
def GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : ClosureOperator α 
Arguments: {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) (x : α)
Goal: gc.closureOperator x = u (l x)
-- closureOperator_gi_self
@[simp]
theorem closureOperator_gi_self [PartialOrder α] (c : ClosureOperator α) :
    c.gi.gc.closureOperator = c 
Arguments: {α : Type u_1} [PartialOrder α] (c : ClosureOperator α)
Goal: ⋯.closureOperator = c
-- InitialSeg.init'
structure InitialSeg {α β : Type*} (r : α → α → Prop) (s : β → β → Prop) extends r ↪r s where
    init' : ∀ a b, s b (toRelEmbedding a) → ∃ a', toRelEmbedding a' = b
Arguments: {α : Type u_4} {β : Type u_5} {r : α → α → Prop} {s : β → β → Prop} (self : r ≼i s) (a : α) (b : β)
Goal: s b (self.toRelEmbedding a) → ∃ a', self.toRelEmbedding a' = b
-- InitialSeg.ext
@[ext] lemma ext {f g : r ≼i s} (h : ∀ x, f x = g x) : f = g 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {f g : r ≼i s} (h : ∀ (x : α), f x = g x)
Goal: f = g
-- InitialSeg.coe_coe_fn
@[simp]
theorem coe_coe_fn (f : r ≼i s) : ((f : r ↪r s) : α → β) = f 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≼i s)
Goal: ⇑f.toRelEmbedding = ⇑f
-- InitialSeg.init
theorem init (f : r ≼i s) {a : α} {b : β} : s b (f a) → ∃ a', f a' = b 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≼i s) {a : α} {b : β}
Goal: s b (f a) → ∃ a', f a' = b
-- InitialSeg.map_rel_iff
theorem map_rel_iff {a b : α} (f : r ≼i s) : s (f a) (f b) ↔ r a b 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {a b : α} (f : r ≼i s)
Goal: s (f a) (f b) ↔ r a b
-- InitialSeg.init_iff
theorem init_iff (f : r ≼i s) {a : α} {b : β} : s b (f a) ↔ ∃ a', f a' = b ∧ r a' a 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≼i s) {a : α} {b : β}
Goal: s b (f a) ↔ ∃ a', f a' = b ∧ r a' a
-- InitialSeg.refl_apply
@[simp]
theorem refl_apply (x : α) : InitialSeg.refl r x = x 
Arguments: {α : Type u_1} {r : α → α → Prop} (x : α)
Goal: (InitialSeg.refl r) x = x