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

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

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

full_name: Lat.instLatticeα
code: instance (X : Lat) : Lattice X 
goal: Lattice ↑X

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

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

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

full_name: Lat.instBundledHomLatticeLatticeHom
code: instance : BundledHom @LatticeHom 
goal: CategoryTheory.BundledHom LatticeHom

full_name: Lat.instLargeCategory
code: instance : LargeCategory.{u} Lat 
goal: CategoryTheory.LargeCategory Lat

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

full_name: Lat.hasForgetToPartOrd
code: instance hasForgetToPartOrd : HasForget₂ Lat PartOrd 
goal: CategoryTheory.HasForget₂ Lat PartOrd

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

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

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

full_name: Lat.dual
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : Lat ⥤ Lat 
goal: Lat ⥤ Lat

full_name: Lat.dual_obj
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : Lat ⥤ Lat 
goal: Lat.dual.obj X = Lat.of (↑X)ᵒᵈ

full_name: Lat.dual_map
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : Lat ⥤ Lat 
goal: ∀ {X Y : Lat} (a : LatticeHom ↑X ↑Y), Lat.dual.map a = LatticeHom.dual a

full_name: Lat.dualEquiv
code: /-- The equivalence between `Lat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : Lat ≌ Lat 
goal: Lat ≌ Lat

full_name: Lat.dualEquiv_functor
code: /-- The equivalence between `Lat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : Lat ≌ Lat 
goal: Lat.dualEquiv.functor = Lat.dual

full_name: Lat.dualEquiv_inverse
code: /-- The equivalence between `Lat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : Lat ≌ Lat 
goal: Lat.dualEquiv.inverse = Lat.dual

full_name: Lat_dual_comp_forget_to_partOrd
code: theorem Lat_dual_comp_forget_to_partOrd :
    Lat.dual ⋙ forget₂ Lat PartOrd = forget₂ Lat PartOrd ⋙ PartOrd.dual 
goal: Lat.dual ⋙ CategoryTheory.forget₂ Lat PartOrd = CategoryTheory.forget₂ Lat PartOrd ⋙ PartOrd.dual
File: Mathlib/Order/ZornAtoms.lean

full_name: IsCoatomic.of_isChain_bounded
code: /-- **Zorn's lemma**: A partial order is coatomic if every nonempty chain `c`, `⊤ ∉ c`, has an upper
bound not equal to `⊤`. -/
theorem IsCoatomic.of_isChain_bounded {α : Type*} [PartialOrder α] [OrderTop α]
    (h :
      ∀ c : Set α,
        IsChain (· ≤ ·) c → c.Nonempty → ⊤ ∉ c → ∃ x ≠ ⊤, x ∈ upperBounds c) :
    IsCoatomic α 
goal: IsCoatomic α

full_name: IsAtomic.of_isChain_bounded
code: /-- **Zorn's lemma**: A partial order is atomic if every nonempty chain `c`, `⊥ ∉ c`, has a lower
bound not equal to `⊥`. -/
theorem IsAtomic.of_isChain_bounded {α : Type*} [PartialOrder α] [OrderBot α]
    (h :
      ∀ c : Set α,
        IsChain (· ≤ ·) c → c.Nonempty → ⊥ ∉ c → ∃ x ≠ ⊥, x ∈ lowerBounds c) :
    IsAtomic α 
goal: IsAtomic α
File: Mathlib/Order/ULift.lean

full_name: ULift.instLE_mathlib
code: instance [LE α] : LE (ULift.{v} α) 
goal: LE (ULift.{v, u} α)

full_name: ULift.up_le
code: @[simp] theorem up_le [LE α] {a b : α} : up a ≤ up b ↔ a ≤ b 
goal: { down := a } ≤ { down := b } ↔ a ≤ b

full_name: ULift.down_le
code: @[simp] theorem down_le [LE α] {a b : ULift α} : down a ≤ down b ↔ a ≤ b 
goal: a.down ≤ b.down ↔ a ≤ b

full_name: ULift.instLT_mathlib
code: instance [LT α] : LT (ULift.{v} α) 
goal: LT (ULift.{v, u} α)

full_name: ULift.up_lt
code: @[simp] theorem up_lt [LT α] {a b : α} : up a < up b ↔ a < b 
goal: { down := a } < { down := b } ↔ a < b

full_name: ULift.down_lt
code: @[simp] theorem down_lt [LT α] {a b : ULift α} : down a < down b ↔ a < b 
goal: a.down < b.down ↔ a < b

full_name: ULift.instOrd_mathlib
code: instance [Ord α] : Ord (ULift.{v} α) 
goal: Ord (ULift.{v, u} α)

full_name: ULift.up_compare
code: @[simp] theorem up_compare [Ord α] (a b : α) : compare (up a) (up b) = compare a b 
goal: compare { down := a } { down := b } = compare a b

full_name: ULift.down_compare
code: @[simp] theorem down_compare [Ord α] (a b : ULift α) :
  compare (down a) (down b) = compare a b 
goal: compare a.down b.down = compare a b

full_name: ULift.instSup
code: instance [Sup α] : Sup (ULift.{v} α) 
goal: Sup (ULift.{v, u} α)

full_name: ULift.up_sup
code: @[simp] theorem up_sup [Sup α] (a b : α) : up (a ⊔ b) = up a ⊔ up b 
goal: { down := a ⊔ b } = { down := a } ⊔ { down := b }

full_name: ULift.down_sup
code: @[simp] theorem down_sup [Sup α] (a b : ULift α) : down (a ⊔ b) = down a ⊔ down b 
goal: (a ⊔ b).down = a.down ⊔ b.down

full_name: ULift.instInf
code: instance [Inf α] : Inf (ULift.{v} α) 
goal: Inf (ULift.{v, u} α)

full_name: ULift.up_inf
code: @[simp] theorem up_inf [Inf α] (a b : α) : up (a ⊓ b) = up a ⊓ up b 
goal: { down := a ⊓ b } = { down := a } ⊓ { down := b }

full_name: ULift.down_inf
code: @[simp] theorem down_inf [Inf α] (a b : ULift α) : down (a ⊓ b) = down a ⊓ down b 
goal: (a ⊓ b).down = a.down ⊓ b.down

full_name: ULift.instSDiff_mathlib
code: instance [SDiff α] : SDiff (ULift.{v} α) 
goal: SDiff (ULift.{v, u} α)

full_name: ULift.up_sdiff
code: @[simp] theorem up_sdiff [SDiff α] (a b : α) : up (a \ b) = up a \ up b 
goal: { down := a \ b } = { down := a } \ { down := b }

full_name: ULift.down_sdiff
code: @[simp] theorem down_sdiff [SDiff α] (a b : ULift α) : down (a \ b) = down a \ down b 
goal: (a \ b).down = a.down \ b.down

full_name: ULift.instHasCompl
code: instance [HasCompl α] : HasCompl (ULift.{v} α) 
goal: HasCompl (ULift.{v, u} α)

full_name: ULift.up_compl
code: @[simp] theorem up_compl [HasCompl α] (a : α) : up (aᶜ) = (up a)ᶜ 
goal: { down := aᶜ } = { down := a }ᶜ

full_name: ULift.down_compl
code: @[simp] theorem down_compl [HasCompl α] (a : ULift α) : down aᶜ = (down a)ᶜ 
goal: aᶜ.down = a.downᶜ

full_name: ULift.instPreorder
code: instance [Preorder α] : Preorder (ULift.{v} α) 
goal: Preorder (ULift.{v, u} α)

full_name: ULift.instPartialOrder
code: instance [PartialOrder α] : PartialOrder (ULift.{v} α) 
goal: PartialOrder (ULift.{v, u} α)
File: Mathlib/Order/Nat.lean

full_name: Nat.instOrderBot
code: instance instOrderBot : OrderBot ℕ 
goal: OrderBot ℕ

full_name: Nat.bot_eq_zero
code: @[simp, nolint simpNF] protected lemma bot_eq_zero : ⊥ = 0 
goal: ⊥ = 0
File: Mathlib/Order/UpperLower/Hom.lean

full_name: UpperSet.iciSupHom
code: /-- `UpperSet.Ici` as a `SupHom`. -/
def iciSupHom : SupHom α (UpperSet α) 
goal: SupHom α (UpperSet α)

full_name: UpperSet.coe_iciSupHom
code: @[simp]
theorem coe_iciSupHom : (iciSupHom : α → UpperSet α) = Ici 
goal: ⇑UpperSet.iciSupHom = UpperSet.Ici

full_name: UpperSet.iciSupHom_apply
code: @[simp]
theorem iciSupHom_apply (a : α) : iciSupHom a = Ici a 
goal: UpperSet.iciSupHom a = UpperSet.Ici a

full_name: UpperSet.icisSupHom
code: /-- `UpperSet.Ici` as a `sSupHom`. -/
def icisSupHom : sSupHom α (UpperSet α) 
goal: sSupHom α (UpperSet α)

full_name: UpperSet.coe_icisSupHom
code: @[simp]
theorem coe_icisSupHom : (icisSupHom : α → UpperSet α) = Ici 
goal: ⇑UpperSet.icisSupHom = UpperSet.Ici

full_name: UpperSet.icisSupHom_apply
code: @[simp]
theorem icisSupHom_apply (a : α) : icisSupHom a = Ici a 
goal: UpperSet.icisSupHom a = UpperSet.Ici a

full_name: LowerSet.iicInfHom
code: /-- `LowerSet.Iic` as an `InfHom`. -/
def iicInfHom : InfHom α (LowerSet α) 
goal: InfHom α (LowerSet α)

full_name: LowerSet.coe_iicInfHom
code: @[simp]
theorem coe_iicInfHom : (iicInfHom : α → LowerSet α) = Iic 
goal: ⇑LowerSet.iicInfHom = LowerSet.Iic

full_name: LowerSet.iicInfHom_apply
code: @[simp]
theorem iicInfHom_apply (a : α) : iicInfHom a = Iic a 
goal: LowerSet.iicInfHom a = LowerSet.Iic a

full_name: LowerSet.iicsInfHom
code: /-- `LowerSet.Iic` as an `sInfHom`. -/
def iicsInfHom : sInfHom α (LowerSet α) 
goal: sInfHom α (LowerSet α)

full_name: LowerSet.coe_iicsInfHom
code: @[simp]
theorem coe_iicsInfHom : (iicsInfHom : α → LowerSet α) = Iic 
goal: ⇑LowerSet.iicsInfHom = LowerSet.Iic

full_name: LowerSet.iicsInfHom_apply
code: @[simp]
theorem iicsInfHom_apply (a : α) : iicsInfHom a = Iic a 
goal: LowerSet.iicsInfHom a = LowerSet.Iic a
File: Mathlib/Order/UpperLower/LocallyFinite.lean

full_name: Set.Finite.upperClosure
code: protected theorem Finite.upperClosure [LocallyFiniteOrderTop α] (hs : s.Finite) :
    (upperClosure s : Set α).Finite 
goal: (↑(upperClosure s)).Finite

full_name: Set.Finite.lowerClosure
code: protected theorem Finite.lowerClosure [LocallyFiniteOrderBot α] (hs : s.Finite) :
    (lowerClosure s : Set α).Finite 
goal: (↑(lowerClosure s)).Finite
File: Mathlib/Order/Bounds/OrderIso.lean

full_name: OrderIso.upperBounds_image
code: theorem upperBounds_image {s : Set α} : upperBounds (f '' s) = f '' upperBounds s 
goal: upperBounds (⇑f '' s) = ⇑f '' upperBounds s

full_name: OrderIso.lowerBounds_image
code: theorem lowerBounds_image {s : Set α} : lowerBounds (f '' s) = f '' lowerBounds s 
goal: lowerBounds (⇑f '' s) = ⇑f '' lowerBounds s

full_name: OrderIso.isLUB_image
code: @[simp]
theorem isLUB_image {s : Set α} {x : β} : IsLUB (f '' s) x ↔ IsLUB s (f.symm x) 
goal: IsLUB (⇑f '' s) x ↔ IsLUB s (f.symm x)

full_name: OrderIso.isLUB_image'
code: theorem isLUB_image' {s : Set α} {x : α} : IsLUB (f '' s) (f x) ↔ IsLUB s x 
goal: IsLUB (⇑f '' s) (f x) ↔ IsLUB s x

full_name: OrderIso.isGLB_image
code: @[simp]
theorem isGLB_image {s : Set α} {x : β} : IsGLB (f '' s) x ↔ IsGLB s (f.symm x) 
goal: IsGLB (⇑f '' s) x ↔ IsGLB s (f.symm x)

full_name: OrderIso.isGLB_image'
code: theorem isGLB_image' {s : Set α} {x : α} : IsGLB (f '' s) (f x) ↔ IsGLB s x 
goal: IsGLB (⇑f '' s) (f x) ↔ IsGLB s x

full_name: OrderIso.isLUB_preimage
code: @[simp]
theorem isLUB_preimage {s : Set β} {x : α} : IsLUB (f ⁻¹' s) x ↔ IsLUB s (f x) 
goal: IsLUB (⇑f ⁻¹' s) x ↔ IsLUB s (f x)

full_name: OrderIso.isLUB_preimage'
code: theorem isLUB_preimage' {s : Set β} {x : β} : IsLUB (f ⁻¹' s) (f.symm x) ↔ IsLUB s x 
goal: IsLUB (⇑f ⁻¹' s) (f.symm x) ↔ IsLUB s x

full_name: OrderIso.isGLB_preimage
code: @[simp]
theorem isGLB_preimage {s : Set β} {x : α} : IsGLB (f ⁻¹' s) x ↔ IsGLB s (f x) 
goal: IsGLB (⇑f ⁻¹' s) x ↔ IsGLB s (f x)

full_name: OrderIso.isGLB_preimage'
code: theorem isGLB_preimage' {s : Set β} {x : β} : IsGLB (f ⁻¹' s) (f.symm x) ↔ IsGLB s x 
goal: IsGLB (⇑f ⁻¹' s) (f.symm x) ↔ IsGLB s x
File: Mathlib/Order/Rel/GaloisConnection.lean

full_name: Rel.leftDual
code: /-- `leftDual` maps any set `J` of elements of type `α` to the set `{b : β | ∀ a ∈ J, R a b}` of
elements `b` of type `β` such that `R a b` for every element `a` of `J`. -/
def leftDual (J : Set α) : Set β 
goal: Set β

full_name: Rel.rightDual
code: /-- `rightDual` maps any set `I` of elements of type `β` to the set `{a : α | ∀ b ∈ I, R a b}`
of elements `a` of type `α` such that `R a b` for every element `b` of `I`. -/
def rightDual (I : Set β) : Set α 
goal: Set α

full_name: Rel.gc_leftDual_rightDual
code: /-- The pair of functions `toDual ∘ leftDual` and `rightDual ∘ ofDual` forms a Galois connection. -/
theorem gc_leftDual_rightDual : GaloisConnection (toDual ∘ R.leftDual) (R.rightDual ∘ ofDual) 
goal: GaloisConnection (⇑OrderDual.toDual ∘ R.leftDual) (R.rightDual ∘ ⇑OrderDual.ofDual)

full_name: Rel.leftFixedPoints
code: /-- `leftFixedPoints` is the set of elements `J : Set α` satisfying `rightDual (leftDual J) = J`. -/
def leftFixedPoints 
goal: Set (Set α)

full_name: Rel.rightFixedPoints
code: /-- `rightFixedPoints` is the set of elements `I : Set β` satisfying `leftDual (rightDual I) = I`.
-/
def rightFixedPoints 
goal: Set (Set β)

full_name: Rel.leftDual_mem_rightFixedPoint
code: /-- `leftDual` maps every element `J` to `rightFixedPoints`. -/
theorem leftDual_mem_rightFixedPoint (J : Set α) : R.leftDual J ∈ R.rightFixedPoints 
goal: R.leftDual J ∈ R.rightFixedPoints

full_name: Rel.rightDual_mem_leftFixedPoint
code: /-- `rightDual` maps every element `I` to `leftFixedPoints`. -/
theorem rightDual_mem_leftFixedPoint (I : Set β) : R.rightDual I ∈ R.leftFixedPoints 
goal: R.rightDual I ∈ R.leftFixedPoints

full_name: Rel.equivFixedPoints
code: /-- The maps `leftDual` and `rightDual` induce inverse bijections between the sets of fixed points.
-/
def equivFixedPoints : R.leftFixedPoints ≃ R.rightFixedPoints 
goal: ↑R.leftFixedPoints ≃ ↑R.rightFixedPoints

full_name: Rel.rightDual_leftDual_le_of_le
code: theorem rightDual_leftDual_le_of_le {J J' : Set α} (h : J' ∈ R.leftFixedPoints) (h₁ : J ≤ J') :
    R.rightDual (R.leftDual J) ≤ J' 
goal: R.rightDual (R.leftDual J) ≤ J'

full_name: Rel.leftDual_rightDual_le_of_le
code: theorem leftDual_rightDual_le_of_le {I I' : Set β} (h : I' ∈ R.rightFixedPoints) (h₁ : I ≤ I') :
    R.leftDual (R.rightDual I) ≤ I' 
goal: R.leftDual (R.rightDual I) ≤ I'
File: Mathlib/Order/Interval/Set/Infinite.lean

full_name: NoMaxOrder.infinite
code: /-- A nonempty preorder with no maximal element is infinite. This is not an instance to avoid
a cycle with `Infinite α → Nontrivial α → Nonempty α`. -/
theorem NoMaxOrder.infinite [Nonempty α] [NoMaxOrder α] : Infinite α 
goal: Infinite α

full_name: NoMinOrder.infinite
code: /-- A nonempty preorder with no minimal element is infinite. This is not an instance to avoid
a cycle with `Infinite α → Nontrivial α → Nonempty α`. -/
theorem NoMinOrder.infinite [Nonempty α] [NoMinOrder α] : Infinite α 
goal: Infinite α

full_name: Set.Ioo.infinite
code: theorem Ioo.infinite : Infinite (Ioo a b) 
goal: Infinite ↑(Set.Ioo a b)

full_name: Set.Ioo_infinite
code: theorem Ioo_infinite : (Ioo a b).Infinite 
goal: (Set.Ioo a b).Infinite

full_name: Set.Ico_infinite
code: theorem Ico_infinite : (Ico a b).Infinite 
goal: (Set.Ico a b).Infinite

full_name: Set.Ico.infinite
code: theorem Ico.infinite : Infinite (Ico a b) 
goal: Infinite ↑(Set.Ico a b)

full_name: Set.Ioc_infinite
code: theorem Ioc_infinite : (Ioc a b).Infinite 
goal: (Set.Ioc a b).Infinite

full_name: Set.Ioc.infinite
code: theorem Ioc.infinite : Infinite (Ioc a b) 
goal: Infinite ↑(Set.Ioc a b)

full_name: Set.Icc_infinite
code: theorem Icc_infinite : (Icc a b).Infinite 
goal: (Set.Icc a b).Infinite

full_name: Set.Icc.infinite
code: theorem Icc.infinite : Infinite (Icc a b) 
goal: Infinite ↑(Set.Icc a b)

full_name: Set.instInfiniteElemIioOfNoMinOrder
code: instance [NoMinOrder α] {a : α} : Infinite (Iio a) 
goal: Infinite ↑(Set.Iio a)

full_name: Set.Iio_infinite
code: theorem Iio_infinite [NoMinOrder α] (a : α) : (Iio a).Infinite 
goal: (Set.Iio a).Infinite

full_name: Set.instInfiniteElemIicOfNoMinOrder
code: instance [NoMinOrder α] {a : α} : Infinite (Iic a) 
goal: Infinite ↑(Set.Iic a)

full_name: Set.Iic_infinite
code: theorem Iic_infinite [NoMinOrder α] (a : α) : (Iic a).Infinite 
goal: (Set.Iic a).Infinite

full_name: Set.instInfiniteElemIoiOfNoMaxOrder
code: instance [NoMaxOrder α] {a : α} : Infinite (Ioi a) 
goal: Infinite ↑(Set.Ioi a)

full_name: Set.Ioi_infinite
code: theorem Ioi_infinite [NoMaxOrder α] (a : α) : (Ioi a).Infinite 
goal: (Set.Ioi a).Infinite

full_name: Set.instInfiniteElemIciOfNoMaxOrder
code: instance [NoMaxOrder α] {a : α} : Infinite (Ici a) 
goal: Infinite ↑(Set.Ici a)

full_name: Set.Ici_infinite
code: theorem Ici_infinite [NoMaxOrder α] (a : α) : (Ici a).Infinite 
goal: (Set.Ici a).Infinite
File: Mathlib/Order/Interval/Set/IsoIoo.lean

full_name: orderIsoIooNegOneOne
code: /-- In a linear ordered field, the whole field is order isomorphic to the open interval `(-1, 1)`.
We consider the actual implementation to be a "black box", so it is irreducible.
-/
@[irreducible]
def orderIsoIooNegOneOne (k : Type*) [LinearOrderedField k] : k ≃o Ioo (-1 : k) 1 
goal: k ≃o ↑(Set.Ioo (-1) 1)
File: Mathlib/Order/Interval/Set/SurjOn.lean

full_name: surjOn_Ioo_of_monotone_surjective
code: theorem surjOn_Ioo_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a b : α) : SurjOn f (Ioo a b) (Ioo (f a) (f b)) 
goal: Set.SurjOn f (Set.Ioo a b) (Set.Ioo (f a) (f b))

full_name: surjOn_Ico_of_monotone_surjective
code: theorem surjOn_Ico_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a b : α) : SurjOn f (Ico a b) (Ico (f a) (f b)) 
goal: Set.SurjOn f (Set.Ico a b) (Set.Ico (f a) (f b))

full_name: surjOn_Ioc_of_monotone_surjective
code: theorem surjOn_Ioc_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a b : α) : SurjOn f (Ioc a b) (Ioc (f a) (f b)) 
goal: Set.SurjOn f (Set.Ioc a b) (Set.Ioc (f a) (f b))

full_name: surjOn_Icc_of_monotone_surjective
code: theorem surjOn_Icc_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    {a b : α} (hab : a ≤ b) : SurjOn f (Icc a b) (Icc (f a) (f b)) 
goal: Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b))

full_name: surjOn_Ioi_of_monotone_surjective
code: theorem surjOn_Ioi_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a : α) : SurjOn f (Ioi a) (Ioi (f a)) 
goal: Set.SurjOn f (Set.Ioi a) (Set.Ioi (f a))

full_name: surjOn_Iio_of_monotone_surjective
code: theorem surjOn_Iio_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a : α) : SurjOn f (Iio a) (Iio (f a)) 
goal: Set.SurjOn f (Set.Iio a) (Set.Iio (f a))

full_name: surjOn_Ici_of_monotone_surjective
code: theorem surjOn_Ici_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a : α) : SurjOn f (Ici a) (Ici (f a)) 
goal: Set.SurjOn f (Set.Ici a) (Set.Ici (f a))

full_name: surjOn_Iic_of_monotone_surjective
code: theorem surjOn_Iic_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a : α) : SurjOn f (Iic a) (Iic (f a)) 
goal: Set.SurjOn f (Set.Iic a) (Set.Iic (f a))
File: Mathlib/Order/Interval/Set/OrderEmbedding.lean

full_name: OrderEmbedding.preimage_Ici
code: @[simp] theorem preimage_Ici : e ⁻¹' Ici (e x) = Ici x 
goal: ⇑e ⁻¹' Set.Ici (e x) = Set.Ici x

full_name: OrderEmbedding.preimage_Iic
code: @[simp] theorem preimage_Iic : e ⁻¹' Iic (e x) = Iic x 
goal: ⇑e ⁻¹' Set.Iic (e x) = Set.Iic x

full_name: OrderEmbedding.preimage_Ioi
code: @[simp] theorem preimage_Ioi : e ⁻¹' Ioi (e x) = Ioi x 
goal: ⇑e ⁻¹' Set.Ioi (e x) = Set.Ioi x

full_name: OrderEmbedding.preimage_Iio
code: @[simp] theorem preimage_Iio : e ⁻¹' Iio (e x) = Iio x 
goal: ⇑e ⁻¹' Set.Iio (e x) = Set.Iio x

full_name: OrderEmbedding.preimage_Icc
code: @[simp] theorem preimage_Icc : e ⁻¹' Icc (e x) (e y) = Icc x y 
goal: ⇑e ⁻¹' Set.Icc (e x) (e y) = Set.Icc x y

full_name: OrderEmbedding.preimage_Ico
code: @[simp] theorem preimage_Ico : e ⁻¹' Ico (e x) (e y) = Ico x y 
goal: ⇑e ⁻¹' Set.Ico (e x) (e y) = Set.Ico x y

full_name: OrderEmbedding.preimage_Ioc
code: @[simp] theorem preimage_Ioc : e ⁻¹' Ioc (e x) (e y) = Ioc x y 
goal: ⇑e ⁻¹' Set.Ioc (e x) (e y) = Set.Ioc x y

full_name: OrderEmbedding.preimage_Ioo
code: @[simp] theorem preimage_Ioo : e ⁻¹' Ioo (e x) (e y) = Ioo x y 
goal: ⇑e ⁻¹' Set.Ioo (e x) (e y) = Set.Ioo x y

full_name: OrderEmbedding.preimage_uIcc
code: @[simp] theorem preimage_uIcc [Lattice β] (e : α ↪o β) (x y : α) :
    e ⁻¹' (uIcc (e x) (e y)) = uIcc x y 
goal: ⇑e ⁻¹' Set.uIcc (e x) (e y) = Set.uIcc x y

full_name: OrderEmbedding.preimage_uIoc
code: @[simp] theorem preimage_uIoc [LinearOrder β] (e : α ↪o β) (x y : α) :
    e ⁻¹' (uIoc (e x) (e y)) = uIoc x y 
goal: ⇑e ⁻¹' Ι (e x) (e y) = Ι x y
File: Mathlib/Order/Interval/Set/OrderIso.lean

full_name: OrderIso.preimage_Iic
code: @[simp]
theorem preimage_Iic (e : α ≃o β) (b : β) : e ⁻¹' Iic b = Iic (e.symm b) 
goal: ⇑e ⁻¹' Set.Iic b = Set.Iic (e.symm b)

full_name: OrderIso.preimage_Ici
code: @[simp]
theorem preimage_Ici (e : α ≃o β) (b : β) : e ⁻¹' Ici b = Ici (e.symm b) 
goal: ⇑e ⁻¹' Set.Ici b = Set.Ici (e.symm b)

full_name: OrderIso.preimage_Iio
code: @[simp]
theorem preimage_Iio (e : α ≃o β) (b : β) : e ⁻¹' Iio b = Iio (e.symm b) 
goal: ⇑e ⁻¹' Set.Iio b = Set.Iio (e.symm b)

full_name: OrderIso.preimage_Ioi
code: @[simp]
theorem preimage_Ioi (e : α ≃o β) (b : β) : e ⁻¹' Ioi b = Ioi (e.symm b) 
goal: ⇑e ⁻¹' Set.Ioi b = Set.Ioi (e.symm b)

full_name: OrderIso.preimage_Icc
code: @[simp]
theorem preimage_Icc (e : α ≃o β) (a b : β) : e ⁻¹' Icc a b = Icc (e.symm a) (e.symm b) 
goal: ⇑e ⁻¹' Set.Icc a b = Set.Icc (e.symm a) (e.symm b)

full_name: OrderIso.preimage_Ico
code: @[simp]
theorem preimage_Ico (e : α ≃o β) (a b : β) : e ⁻¹' Ico a b = Ico (e.symm a) (e.symm b) 
goal: ⇑e ⁻¹' Set.Ico a b = Set.Ico (e.symm a) (e.symm b)

full_name: OrderIso.preimage_Ioc
code: @[simp]
theorem preimage_Ioc (e : α ≃o β) (a b : β) : e ⁻¹' Ioc a b = Ioc (e.symm a) (e.symm b) 
goal: ⇑e ⁻¹' Set.Ioc a b = Set.Ioc (e.symm a) (e.symm b)

full_name: OrderIso.preimage_Ioo
code: @[simp]
theorem preimage_Ioo (e : α ≃o β) (a b : β) : e ⁻¹' Ioo a b = Ioo (e.symm a) (e.symm b) 
goal: ⇑e ⁻¹' Set.Ioo a b = Set.Ioo (e.symm a) (e.symm b)

full_name: OrderIso.image_Iic
code: @[simp]
theorem image_Iic (e : α ≃o β) (a : α) : e '' Iic a = Iic (e a) 
goal: ⇑e '' Set.Iic a = Set.Iic (e a)

full_name: OrderIso.image_Ici
code: @[simp]
theorem image_Ici (e : α ≃o β) (a : α) : e '' Ici a = Ici (e a) 
goal: ⇑e '' Set.Ici a = Set.Ici (e a)

full_name: OrderIso.image_Iio
code: @[simp]
theorem image_Iio (e : α ≃o β) (a : α) : e '' Iio a = Iio (e a) 
goal: ⇑e '' Set.Iio a = Set.Iio (e a)

full_name: OrderIso.image_Ioi
code: @[simp]
theorem image_Ioi (e : α ≃o β) (a : α) : e '' Ioi a = Ioi (e a) 
goal: ⇑e '' Set.Ioi a = Set.Ioi (e a)

full_name: OrderIso.image_Ioo
code: @[simp]
theorem image_Ioo (e : α ≃o β) (a b : α) : e '' Ioo a b = Ioo (e a) (e b) 
goal: ⇑e '' Set.Ioo a b = Set.Ioo (e a) (e b)

full_name: OrderIso.image_Ioc
code: @[simp]
theorem image_Ioc (e : α ≃o β) (a b : α) : e '' Ioc a b = Ioc (e a) (e b) 
goal: ⇑e '' Set.Ioc a b = Set.Ioc (e a) (e b)

full_name: OrderIso.image_Ico
code: @[simp]
theorem image_Ico (e : α ≃o β) (a b : α) : e '' Ico a b = Ico (e a) (e b) 
goal: ⇑e '' Set.Ico a b = Set.Ico (e a) (e b)

full_name: OrderIso.image_Icc
code: @[simp]
theorem image_Icc (e : α ≃o β) (a b : α) : e '' Icc a b = Icc (e a) (e b) 
goal: ⇑e '' Set.Icc a b = Set.Icc (e a) (e b)

full_name: OrderIso.IicTop
code: /-- Order isomorphism between `Iic (⊤ : α)` and `α` when `α` has a top element -/
def IicTop {α : Type*} [Preorder α] [OrderTop α] : Iic (⊤ : α) ≃o α 
goal: ↑(Set.Iic ⊤) ≃o α

full_name: OrderIso.IciBot
code: /-- Order isomorphism between `Ici (⊥ : α)` and `α` when `α` has a bottom element -/
def IciBot {α : Type*} [Preorder α] [OrderBot α] : Ici (⊥ : α) ≃o α 
goal: ↑(Set.Ici ⊥) ≃o α