ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Order/KrullDimension.lean

full_name: krullDim
code: /--
The **Krull dimension** of a preorder `α` is the supremum of the rightmost index of all relation
series of `α` order by `<`. If there is no series `a₀ < a₁ < ... < aₙ` in `α`, then its Krull
dimension is defined to be negative infinity; if the length of all series `a₀ < a₁ < ... < aₙ` is
unbounded, its Krull dimension is defined to be positive infinity.
-/
noncomputable def krullDim : WithBot (WithTop ℕ) 
goal: WithBot (WithTop ℕ)

full_name: height
code: /--
Height of an element `a` of a preordered set `α` is the Krull dimension of the subset `(-∞, a]`
-/
noncomputable def height (a : α) : WithBot (WithTop ℕ) 
goal: WithBot (WithTop ℕ)

full_name: coheight
code: /--
Coheight of an element `a` of a pre-ordered set `α` is the Krull dimension of the subset `[a, +∞)`
-/
noncomputable def coheight (a : α) : WithBot (WithTop ℕ) 
goal: WithBot (WithTop ℕ)

full_name: krullDim_nonneg_of_nonempty
code: lemma krullDim_nonneg_of_nonempty [Nonempty α] : 0 ≤ krullDim α 
goal: 0 ≤ krullDim α

full_name: krullDim_eq_bot_of_isEmpty
code: lemma krullDim_eq_bot_of_isEmpty [IsEmpty α] : krullDim α = ⊥ 
goal: krullDim α = ⊥

full_name: krullDim_eq_top_of_infiniteDimensionalOrder
code: lemma krullDim_eq_top_of_infiniteDimensionalOrder [InfiniteDimensionalOrder α] :
    krullDim α = ⊤ 
goal: krullDim α = ⊤

full_name: krullDim_le_of_strictMono
code: lemma krullDim_le_of_strictMono (f : α → β) (hf : StrictMono f) : krullDim α ≤ krullDim β 
goal: krullDim α ≤ krullDim β

full_name: height_mono
code: lemma height_mono {a b : α} (h : a ≤ b) : height α a ≤ height α b 
goal: height α a ≤ height α b

full_name: krullDim_eq_length_of_finiteDimensionalOrder
code: lemma krullDim_eq_length_of_finiteDimensionalOrder [FiniteDimensionalOrder α] :
    krullDim α = (LTSeries.longestOf α).length 
goal: krullDim α = ↑(LTSeries.longestOf α).length

full_name: krullDim_eq_zero_of_unique
code: lemma krullDim_eq_zero_of_unique [Unique α] : krullDim α = 0 
goal: krullDim α = 0

full_name: krullDim_le_of_strictComono_and_surj
code: lemma krullDim_le_of_strictComono_and_surj
    (f : α → β) (hf : ∀ ⦃a b⦄, f a < f b → a < b) (hf' : Function.Surjective f) :
    krullDim β ≤ krullDim α 
goal: krullDim β ≤ krullDim α

full_name: krullDim_eq_of_orderIso
code: lemma krullDim_eq_of_orderIso (f : α ≃o β) : krullDim α = krullDim β 
goal: krullDim α = krullDim β

full_name: krullDim_eq_iSup_height
code: lemma krullDim_eq_iSup_height : krullDim α = ⨆ (a : α), height α a 
goal: krullDim α = ⨆ a, height α a

full_name: krullDim_orderDual
code: @[simp] lemma krullDim_orderDual : krullDim αᵒᵈ = krullDim α 
goal: krullDim αᵒᵈ = krullDim α
File: Mathlib/Order/Extension/Well.lean

full_name: WellFounded.wellOrderExtension
code: /-- An arbitrary well order on `α` that extends `r`.

The construction maps `r` into two well-orders: the first map is `WellFounded.rank`, which is not
necessarily injective but respects the order `r`; the other map is the identity (with an arbitrarily
chosen well-order on `α`), which is injective but doesn't respect `r`.

By taking the lexicographic product of the two, we get both properties, so we can pull it back and
get a well-order that extend our original order `r`. Another way to view this is that we choose an
arbitrary well-order to serve as a tiebreak between two elements of same rank.
-/
noncomputable def wellOrderExtension : LinearOrder α 
goal: LinearOrder α

full_name: WellFounded.wellOrderExtension.isWellFounded_lt
code: instance wellOrderExtension.isWellFounded_lt : IsWellFounded α hwf.wellOrderExtension.lt 
goal: IsWellFounded α LT.lt

full_name: WellFounded.exists_well_order_ge
code: /-- Any well-founded relation can be extended to a well-ordering on that type. -/
theorem exists_well_order_ge : ∃ s, r ≤ s ∧ IsWellOrder α s 
goal: ∃ s, r ≤ s ∧ IsWellOrder α s

full_name: WellOrderExtension
code: /-- A type alias for `α`, intended to extend a well-founded order on `α` to a well-order. -/
def WellOrderExtension (α : Type*) : Type _ 
goal: Type u_1

full_name: instInhabitedWellOrderExtension
code: instance [Inhabited α] : Inhabited (WellOrderExtension α) 
goal: Inhabited (WellOrderExtension α)

full_name: toWellOrderExtension
code: /-- "Identity" equivalence between a well-founded order and its well-order extension. -/
def toWellOrderExtension : α ≃ WellOrderExtension α 
goal: α ≃ WellOrderExtension α

full_name: instLinearOrderWellOrderExtensionOfWellFoundedLT
code: noncomputable instance [LT α] [WellFoundedLT α] : LinearOrder (WellOrderExtension α) 
goal: LinearOrder (WellOrderExtension α)

full_name: WellOrderExtension.wellFoundedLT
code: instance WellOrderExtension.wellFoundedLT [LT α] [WellFoundedLT α] :
    WellFoundedLT (WellOrderExtension α) 
goal: WellFoundedLT (WellOrderExtension α)

full_name: toWellOrderExtension_strictMono
code: theorem toWellOrderExtension_strictMono [Preorder α] [WellFoundedLT α] :
    StrictMono (toWellOrderExtension : α → WellOrderExtension α) 
goal: StrictMono ⇑toWellOrderExtension
File: Mathlib/Order/Heyting/Boundary.lean

full_name: Coheyting.boundary
code: /-- The boundary of an element of a co-Heyting algebra is the intersection of its Heyting negation
with itself. Note that this is always `⊥` for a boolean algebra. -/
def boundary (a : α) : α 
goal: α

full_name: Heyting.«_aux_Mathlib_Order_Heyting_Boundary___macroRules_Heyting_term∂__1»
code: /-- The boundary of an element of a co-Heyting algebra. -/
scoped[Heyting] prefix:120 "∂ " => Coheyting.boundary
goal: Lean.Macro

full_name: Heyting._aux_Mathlib_Order_Heyting_Boundary___unexpand_Coheyting_boundary_1
code: /-- The boundary of an element of a co-Heyting algebra. -/
scoped[Heyting] prefix:120 "∂ " => Coheyting.boundary
goal: Lean.PrettyPrinter.Unexpander

full_name: Coheyting.inf_hnot_self
code: theorem inf_hnot_self (a : α) : a ⊓ ￢a = ∂ a 
goal: a ⊓ ￢a = ∂ a

full_name: Coheyting.boundary_le
code: theorem boundary_le : ∂ a ≤ a 
goal: ∂ a ≤ a

full_name: Coheyting.boundary_le_hnot
code: theorem boundary_le_hnot : ∂ a ≤ ￢a 
goal: ∂ a ≤ ￢a

full_name: Coheyting.boundary_bot
code: @[simp]
theorem boundary_bot : ∂ (⊥ : α) = ⊥ 
goal: ∂ ⊥ = ⊥

full_name: Coheyting.boundary_top
code: @[simp]
theorem boundary_top : ∂ (⊤ : α) = ⊥ 
goal: ∂ ⊤ = ⊥

full_name: Coheyting.boundary_hnot_le
code: theorem boundary_hnot_le (a : α) : ∂ (￢a) ≤ ∂ a 
goal: ∂ (￢a) ≤ ∂ a

full_name: Coheyting.boundary_hnot_hnot
code: @[simp]
theorem boundary_hnot_hnot (a : α) : ∂ (￢￢a) = ∂ (￢a) 
goal: ∂ (￢￢a) = ∂ (￢a)

full_name: Coheyting.hnot_boundary
code: @[simp]
theorem hnot_boundary (a : α) : ￢∂ a = ⊤ 
goal: ￢∂ a = ⊤

full_name: Coheyting.boundary_inf
code: /-- **Leibniz rule** for the co-Heyting boundary. -/
theorem boundary_inf (a b : α) : ∂ (a ⊓ b) = ∂ a ⊓ b ⊔ a ⊓ ∂ b 
goal: ∂ (a ⊓ b) = ∂ a ⊓ b ⊔ a ⊓ ∂ b

full_name: Coheyting.boundary_inf_le
code: theorem boundary_inf_le : ∂ (a ⊓ b) ≤ ∂ a ⊔ ∂ b 
goal: ∂ (a ⊓ b) ≤ ∂ a ⊔ ∂ b

full_name: Coheyting.boundary_sup_le
code: theorem boundary_sup_le : ∂ (a ⊔ b) ≤ ∂ a ⊔ ∂ b 
goal: ∂ (a ⊔ b) ≤ ∂ a ⊔ ∂ b

full_name: Coheyting.boundary_le_boundary_sup_sup_boundary_inf_left
code: theorem boundary_le_boundary_sup_sup_boundary_inf_left : ∂ a ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) 
goal: ∂ a ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)

full_name: Coheyting.boundary_le_boundary_sup_sup_boundary_inf_right
code: theorem boundary_le_boundary_sup_sup_boundary_inf_right : ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) 
goal: ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)

full_name: Coheyting.boundary_sup_sup_boundary_inf
code: theorem boundary_sup_sup_boundary_inf (a b : α) : ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) = ∂ a ⊔ ∂ b 
goal: ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) = ∂ a ⊔ ∂ b

full_name: Coheyting.boundary_idem
code: @[simp]
theorem boundary_idem (a : α) : ∂ ∂ a = ∂ a 
goal: ∂ ∂ a = ∂ a

full_name: Coheyting.hnot_hnot_sup_boundary
code: theorem hnot_hnot_sup_boundary (a : α) : ￢￢a ⊔ ∂ a = a 
goal: ￢￢a ⊔ ∂ a = a

full_name: Coheyting.hnot_eq_top_iff_exists_boundary
code: theorem hnot_eq_top_iff_exists_boundary : ￢a = ⊤ ↔ ∃ b, ∂ b = a 
goal: ￢a = ⊤ ↔ ∃ b, ∂ b = a

full_name: Coheyting.boundary_eq_bot
code: @[simp]
theorem Coheyting.boundary_eq_bot (a : α) : ∂ a = ⊥ 
goal: ∂ a = ⊥
File: Mathlib/Order/RelIso/Group.lean

full_name: RelIso.instGroup
code: instance : Group (r ≃r r) 
goal: Group (r ≃r r)

full_name: RelIso.coe_one
code: @[simp]
theorem coe_one : ((1 : r ≃r r) : α → α) = id 
goal: ⇑1 = id

full_name: RelIso.coe_mul
code: @[simp]
theorem coe_mul (e₁ e₂ : r ≃r r) : ((e₁ * e₂) : α → α) = e₁ ∘ e₂ 
goal: ⇑(e₁ * e₂) = ⇑e₁ ∘ ⇑e₂

full_name: RelIso.mul_apply
code: theorem mul_apply (e₁ e₂ : r ≃r r) (x : α) : (e₁ * e₂) x = e₁ (e₂ x) 
goal: (e₁ * e₂) x = e₁ (e₂ x)

full_name: RelIso.inv_apply_self
code: @[simp]
theorem inv_apply_self (e : r ≃r r) (x) : e⁻¹ (e x) = x 
goal: e⁻¹ (e x) = x

full_name: RelIso.apply_inv_self
code: @[simp]
theorem apply_inv_self (e : r ≃r r) (x) : e (e⁻¹ x) = x 
goal: e (e⁻¹ x) = x
File: Mathlib/Order/RelIso/Set.lean

full_name: RelHomClass.map_inf
code: theorem map_inf [SemilatticeInf α] [LinearOrder β] [FunLike F β α]
    [RelHomClass F (· < ·) (· < ·)] (a : F) (m n : β) :
    a (m ⊓ n) = a m ⊓ a n 
goal: a (m ⊓ n) = a m ⊓ a n

full_name: RelHomClass.map_sup
code: theorem map_sup [SemilatticeSup α] [LinearOrder β] [FunLike F β α]
    [RelHomClass F (· > ·) (· > ·)] (a : F) (m n : β) :
    a (m ⊔ n) = a m ⊔ a n 
goal: a (m ⊔ n) = a m ⊔ a n

full_name: RelIso.range_eq
code: @[simp]
theorem range_eq (e : r ≃r s) : Set.range e = Set.univ 
goal: Set.range ⇑e = Set.univ

full_name: Subrel
code: /-- `Subrel r p` is the inherited relation on a subset. -/
def Subrel (r : α → α → Prop) (p : Set α) : p → p → Prop 
goal: ↑p → ↑p → Prop

full_name: subrel_val
code: @[simp]
theorem subrel_val (r : α → α → Prop) (p : Set α) {a b} : Subrel r p a b ↔ r a.1 b.1 
goal: Subrel r p a b ↔ r ↑a ↑b

full_name: Subrel.relEmbedding
code: /-- The relation embedding from the inherited relation on a subset. -/
protected def relEmbedding (r : α → α → Prop) (p : Set α) : Subrel r p ↪r r 
goal: Subrel r p ↪r r

full_name: Subrel.relEmbedding_apply
code: @[simp]
theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1 
goal: (Subrel.relEmbedding r p) a = ↑a

full_name: Subrel.instIsWellOrderElem
code: instance (r : α → α → Prop) [IsWellOrder α r] (p : Set α) : IsWellOrder p (Subrel r p) 
goal: IsWellOrder (↑p) (Subrel r p)

full_name: Subrel.instIsReflElem
code: instance (r : α → α → Prop) [IsRefl α r] (p : Set α) : IsRefl p (Subrel r p) 
goal: IsRefl (↑p) (Subrel r p)

full_name: Subrel.instIsSymmElem
code: instance (r : α → α → Prop) [IsSymm α r] (p : Set α) : IsSymm p (Subrel r p) 
goal: IsSymm (↑p) (Subrel r p)

full_name: Subrel.instIsTransElem
code: instance (r : α → α → Prop) [IsTrans α r] (p : Set α) : IsTrans p (Subrel r p) 
goal: IsTrans (↑p) (Subrel r p)

full_name: Subrel.instIsIrreflElem
code: instance (r : α → α → Prop) [IsIrrefl α r] (p : Set α) : IsIrrefl p (Subrel r p) 
goal: IsIrrefl (↑p) (Subrel r p)

full_name: RelEmbedding.codRestrict
code: /-- Restrict the codomain of a relation embedding. -/
def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p) : r ↪r Subrel s p 
goal: r ↪r Subrel s p

full_name: RelEmbedding.codRestrict_apply
code: @[simp]
theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :
    RelEmbedding.codRestrict p f H a = ⟨f a, H a⟩ 
goal: (RelEmbedding.codRestrict p f H) a = ⟨f a, ⋯⟩

full_name: RelIso.image_eq_preimage_symm
code: theorem RelIso.image_eq_preimage_symm (e : r ≃r s) (t : Set α) : e '' t = e.symm ⁻¹' t 
goal: ⇑e '' t = ⇑e.symm ⁻¹' t

full_name: RelIso.preimage_eq_image_symm
code: theorem RelIso.preimage_eq_image_symm (e : r ≃r s) (t : Set β) : e ⁻¹' t = e.symm '' t 
goal: ⇑e ⁻¹' t = ⇑e.symm '' t
File: Mathlib/Order/Extension/Linear.lean

full_name: extend_partialOrder
code: /-- Any partial order can be extended to a linear order.
-/
theorem extend_partialOrder {α : Type u} (r : α → α → Prop) [IsPartialOrder α r] :
    ∃ s : α → α → Prop, IsLinearOrder α s ∧ r ≤ s 
goal: ∃ s, IsLinearOrder α s ∧ r ≤ s

full_name: LinearExtension
code: /-- A type alias for `α`, intended to extend a partial order on `α` to a linear order. -/
def LinearExtension (α : Type u) : Type u 
goal: Type u

full_name: instLinearOrderLinearExtensionOfPartialOrder
code: noncomputable instance {α : Type u} [PartialOrder α] : LinearOrder (LinearExtension α) 
goal: LinearOrder (LinearExtension α)

full_name: toLinearExtension
code: /-- The embedding of `α` into `LinearExtension α` as an order homomorphism. -/
def toLinearExtension {α : Type u} [PartialOrder α] : α →o LinearExtension α 
goal: α →o LinearExtension α

full_name: instInhabitedLinearExtension
code: instance {α : Type u} [Inhabited α] : Inhabited (LinearExtension α) 
goal: Inhabited (LinearExtension α)
File: Mathlib/Order/ConditionallyCompleteLattice/Group.lean

full_name: le_mul_ciInf
code: @[to_additive]
theorem le_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)] {a : α} {g : α} {h : ι → α}
    (H : ∀ j, a ≤ g * h j) : a ≤ g * iInf h 
goal: a ≤ g * iInf h

full_name: le_add_ciInf
code: @[to_additive]
theorem le_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)] {a : α} {g : α} {h : ι → α}
    (H : ∀ j, a ≤ g * h j) : a ≤ g * iInf h 
goal: a ≤ g + iInf h

full_name: add_ciSup_le
code: @[to_additive]
theorem mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)] {a : α} {g : α} {h : ι → α}
    (H : ∀ j, g * h j ≤ a) : g * iSup h ≤ a 
goal: g + iSup h ≤ a

full_name: mul_ciSup_le
code: @[to_additive]
theorem mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)] {a : α} {g : α} {h : ι → α}
    (H : ∀ j, g * h j ≤ a) : g * iSup h ≤ a 
goal: g * iSup h ≤ a

full_name: le_ciInf_add
code: @[to_additive]
theorem le_ciInf_mul [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α}
    {h : α} (H : ∀ i, a ≤ g i * h) : a ≤ iInf g * h 
goal: a ≤ iInf g + h

full_name: le_ciInf_mul
code: @[to_additive]
theorem le_ciInf_mul [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α}
    {h : α} (H : ∀ i, a ≤ g i * h) : a ≤ iInf g * h 
goal: a ≤ iInf g * h

full_name: ciSup_add_le
code: @[to_additive]
theorem ciSup_mul_le [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α}
    {h : α} (H : ∀ i, g i * h ≤ a) : iSup g * h ≤ a 
goal: iSup g + h ≤ a

full_name: ciSup_mul_le
code: @[to_additive]
theorem ciSup_mul_le [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α}
    {h : α} (H : ∀ i, g i * h ≤ a) : iSup g * h ≤ a 
goal: iSup g * h ≤ a

full_name: le_ciInf_mul_ciInf
code: @[to_additive]
theorem le_ciInf_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, a ≤ g i * h j) : a ≤ iInf g * iInf h 
goal: a ≤ iInf g * iInf h

full_name: le_ciInf_add_ciInf
code: @[to_additive]
theorem le_ciInf_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, a ≤ g i * h j) : a ≤ iInf g * iInf h 
goal: a ≤ iInf g + iInf h

full_name: ciSup_mul_ciSup_le
code: @[to_additive]
theorem ciSup_mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, g i * h j ≤ a) : iSup g * iSup h ≤ a 
goal: iSup g * iSup h ≤ a

full_name: ciSup_add_ciSup_le
code: @[to_additive]
theorem ciSup_mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, g i * h j ≤ a) : iSup g * iSup h ≤ a 
goal: iSup g + iSup h ≤ a
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

full_name: Finset.Nonempty.csSup_eq_max'
code: theorem Finset.Nonempty.csSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h 
goal: sSup ↑s = s.max' h

full_name: Finset.Nonempty.csInf_eq_min'
code: theorem Finset.Nonempty.csInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h 
goal: sInf ↑s = s.min' h

full_name: Finset.Nonempty.csSup_mem
code: theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s 
goal: sSup ↑s ∈ s

full_name: Finset.Nonempty.csInf_mem
code: theorem Finset.Nonempty.csInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s 
goal: sInf ↑s ∈ s

full_name: Set.Nonempty.csSup_mem
code: theorem Set.Nonempty.csSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s 
goal: sSup s ∈ s

full_name: Set.Nonempty.csInf_mem
code: theorem Set.Nonempty.csInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s 
goal: sInf s ∈ s

full_name: Set.Finite.csSup_lt_iff
code: theorem Set.Finite.csSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a 
goal: sSup s < a ↔ ∀ x ∈ s, x < a

full_name: Set.Finite.lt_csInf_iff
code: theorem Set.Finite.lt_csInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x 
goal: a < sInf s ↔ ∀ x ∈ s, a < x

full_name: Finset.sup'_eq_csSup_image
code: theorem sup'_eq_csSup_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
    s.sup' H f = sSup (f '' s) 
goal: s.sup' H f = sSup (f '' ↑s)

full_name: Finset.inf'_eq_csInf_image
code: theorem inf'_eq_csInf_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
    s.inf' H f = sInf (f '' s) 
goal: s.inf' H f = sInf (f '' ↑s)

full_name: Finset.sup'_id_eq_csSup
code: theorem sup'_id_eq_csSup (s : Finset α) (hs) : s.sup' hs id = sSup s 
goal: s.sup' hs id = sSup ↑s

full_name: Finset.inf'_id_eq_csInf
code: theorem inf'_id_eq_csInf (s : Finset α) (hs) : s.inf' hs id = sInf s 
goal: s.inf' hs id = sInf ↑s

full_name: Finset.sup'_univ_eq_ciSup
code: lemma sup'_univ_eq_ciSup (f : ι → α) : univ.sup' univ_nonempty f = ⨆ i, f i 
goal: Finset.univ.sup' ⋯ f = ⨆ i, f i

full_name: Finset.inf'_univ_eq_ciInf
code: lemma inf'_univ_eq_ciInf (f : ι → α) : univ.inf' univ_nonempty f = ⨅ i, f i 
goal: Finset.univ.inf' ⋯ f = ⨅ i, f i

full_name: Finset.sup_univ_eq_ciSup
code: lemma sup_univ_eq_ciSup [Fintype ι] (f : ι → α) : univ.sup f = ⨆ i, f i 
goal: Finset.univ.sup f = ⨆ i, f i
File: Mathlib/Order/CompactlyGenerated/Intervals.lean

full_name: Set.Iic.isCompactElement
code: theorem isCompactElement {a : α} {b : Iic a} (h : CompleteLattice.IsCompactElement (b : α)) :
    CompleteLattice.IsCompactElement b 
goal: CompleteLattice.IsCompactElement b

full_name: Set.Iic.instIsCompactlyGenerated
code: instance instIsCompactlyGenerated [IsCompactlyGenerated α] {a : α} :
    IsCompactlyGenerated (Iic a) 
goal: IsCompactlyGenerated ↑(Set.Iic a)

full_name: complementedLattice_of_complementedLattice_Iic
code: theorem complementedLattice_of_complementedLattice_Iic
    [IsModularLattice α] [IsCompactlyGenerated α]
    {s : Set ι} {f : ι → α}
    (h : ∀ i ∈ s, ComplementedLattice <| Iic (f i))
    (h' : ⨆ i ∈ s, f i = ⊤) :
    ComplementedLattice α 
goal: ComplementedLattice α
File: Mathlib/Order/Category/Frm.lean

full_name: Frm
code: /-- The category of frames. -/
def Frm 
goal: Type (u_1 + 1)

full_name: Frm.instCoeSortType
code: instance : CoeSort Frm Type* 
goal: CoeSort Frm (Type u_1)

full_name: Frm.instFrameα
code: instance (X : Frm) : Frame X 
goal: Order.Frame ↑X

full_name: Frm.of
code: /-- Construct a bundled `Frm` from a `Frame`. -/
def of (α : Type*) [Frame α] : Frm 
goal: Frm

full_name: Frm.coe_of
code: @[simp]
theorem coe_of (α : Type*) [Frame α] : ↥(of α) = α 
goal: ↑(Frm.of α) = α

full_name: Frm.instInhabited
code: instance : Inhabited Frm 
goal: Inhabited Frm

full_name: Frm.Hom
code: /-- An abbreviation of `FrameHom` that assumes `Frame` instead of the weaker `CompleteLattice`.
Necessary for the category theory machinery. -/
abbrev Hom (α β : Type*) [Frame α] [Frame β] : Type _ 
goal: Type (max u_2 u_1)

full_name: Frm.bundledHom
code: instance bundledHom : BundledHom Hom 
goal: CategoryTheory.BundledHom Frm.Hom

full_name: Frm.instConcreteCategory
code: instance : ConcreteCategory Frm 
goal: CategoryTheory.ConcreteCategory Frm

full_name: Frm.hasForgetToLat
code: instance hasForgetToLat : HasForget₂ Frm Lat 
goal: CategoryTheory.HasForget₂ Frm Lat

full_name: Frm.Iso.mk_hom_toFun
code: /-- Constructs an isomorphism of frames from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : Frm.{u}} (e : α ≃o β) : α ≅ β 
goal: (Frm.Iso.mk e).hom a = e a

full_name: Frm.Iso.mk
code: /-- Constructs an isomorphism of frames from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : Frm.{u}} (e : α ≃o β) : α ≅ β 
goal: α ≅ β

full_name: Frm.Iso.mk_inv_toFun
code: /-- Constructs an isomorphism of frames from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : Frm.{u}} (e : α ≃o β) : α ≅ β 
goal: (Frm.Iso.mk e).inv a = e.symm a

full_name: topCatOpToFrm
code: /-- The forgetful functor from `TopCatᵒᵖ` to `Frm`. -/
@[simps]
def topCatOpToFrm : TopCatᵒᵖ ⥤ Frm 
goal: TopCatᵒᵖ ⥤ Frm

full_name: topCatOpToFrm_obj
code: /-- The forgetful functor from `TopCatᵒᵖ` to `Frm`. -/
@[simps]
def topCatOpToFrm : TopCatᵒᵖ ⥤ Frm 
goal: topCatOpToFrm.obj X = Frm.of (TopologicalSpace.Opens ↑(Opposite.unop X))

full_name: topCatOpToFrm_map
code: /-- The forgetful functor from `TopCatᵒᵖ` to `Frm`. -/
@[simps]
def topCatOpToFrm : TopCatᵒᵖ ⥤ Frm 
goal: ∀ {X Y : TopCatᵒᵖ} (f : X ⟶ Y), topCatOpToFrm.map f = TopologicalSpace.Opens.comap f.unop

full_name: CompHausOpToFrame.faithful
code: instance CompHausOpToFrame.faithful : (compHausToTop.op ⋙ topCatOpToFrm.{u}).Faithful 
goal: (compHausToTop.op ⋙ topCatOpToFrm).Faithful
File: Mathlib/Order/Category/HeytAlg.lean

full_name: HeytAlg
code: /-- The category of Heyting algebras. -/
def HeytAlg 
goal: Type (u_1 + 1)

full_name: HeytAlg.instCoeSortType
code: instance : CoeSort HeytAlg Type* 
goal: CoeSort HeytAlg (Type u_1)

full_name: HeytAlg.instHeytingAlgebraα
code: instance (X : HeytAlg) : HeytingAlgebra X 
goal: HeytingAlgebra ↑X

full_name: HeytAlg.of
code: /-- Construct a bundled `HeytAlg` from a `HeytingAlgebra`. -/
def of (α : Type*) [HeytingAlgebra α] : HeytAlg 
goal: HeytAlg

full_name: HeytAlg.coe_of
code: @[simp]
theorem coe_of (α : Type*) [HeytingAlgebra α] : ↥(of α) = α 
goal: ↑(HeytAlg.of α) = α

full_name: HeytAlg.instInhabited
code: instance : Inhabited HeytAlg 
goal: Inhabited HeytAlg

full_name: HeytAlg.bundledHom
code: instance bundledHom : BundledHom HeytingHom 
goal: CategoryTheory.BundledHom HeytingHom

full_name: HeytAlg.instConcreteCategory
code: instance : ConcreteCategory HeytAlg 
goal: CategoryTheory.ConcreteCategory HeytAlg

full_name: HeytAlg.instFunLikeHomαHeytingAlgebra
code: instance {X Y : HeytAlg.{u}} : FunLike (X ⟶ Y) ↑X ↑Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: HeytAlg.instHeytingHomClassHomαHeytingAlgebra
code: instance {X Y : HeytAlg.{u}} : HeytingHomClass (X ⟶ Y) ↑X ↑Y 
goal: HeytingHomClass (X ⟶ Y) ↑X ↑Y

full_name: HeytAlg.hasForgetToLat_forget₂_obj
code: @[simps]
instance hasForgetToLat : HasForget₂ HeytAlg BddDistLat 
goal: CategoryTheory.HasForget₂.forget₂.obj X = BddDistLat.of ↑X

full_name: HeytAlg.hasForgetToLat
code: @[simps]
instance hasForgetToLat : HasForget₂ HeytAlg BddDistLat 
goal: CategoryTheory.HasForget₂ HeytAlg BddDistLat

full_name: HeytAlg.hasForgetToLat_forget₂_map_toLatticeHom_toSupHom_toFun
code: @[simps]
instance hasForgetToLat : HasForget₂ HeytAlg BddDistLat 
goal: (CategoryTheory.HasForget₂.forget₂.map f).toSupHom a = f a

full_name: HeytAlg.Iso.mk_inv_toFun
code: /-- Constructs an isomorphism of Heyting algebras from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : HeytAlg.{u}} (e : α ≃o β) : α ≅ β 
goal: (HeytAlg.Iso.mk e).inv a = e.symm a

full_name: HeytAlg.Iso.mk_hom_toFun
code: /-- Constructs an isomorphism of Heyting algebras from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : HeytAlg.{u}} (e : α ≃o β) : α ≅ β 
goal: (HeytAlg.Iso.mk e).hom a = e a

full_name: HeytAlg.Iso.mk
code: /-- Constructs an isomorphism of Heyting algebras from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : HeytAlg.{u}} (e : α ≃o β) : α ≅ β 
goal: α ≅ β