ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Subobject.bot_factors_iff_zero
theorem bot_factors_iff_zero {A B : C} (f : A ⟶ B) : (⊥ : Subobject B).Factors f ↔ f = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {A B : C} (f : A ⟶ B)
Goal: ⊥.Factors f ↔ f = 0
-- CategoryTheory.Subobject.mk_eq_bot_iff_zero
theorem mk_eq_bot_iff_zero {f : X ⟶ Y} [Mono f] : Subobject.mk f = ⊥ ↔ f = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Mono f]
Goal: CategoryTheory.Subobject.mk f = ⊥ ↔ f = 0
-- CategoryTheory.Subobject.functor_obj
@[simps]
def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] (X : Cᵒᵖ)
Goal: (CategoryTheory.Subobject.functor C).obj X = CategoryTheory.Subobject (Opposite.unop X)
-- CategoryTheory.Subobject.functor_map
@[simps]
def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C]
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : CategoryTheory.Subobject (Opposite.unop X)),
  (CategoryTheory.Subobject.functor C).map f a = (CategoryTheory.Subobject.pullback f.unop).obj a
-- CategoryTheory.Subobject.inf_le_left
theorem inf_le_left {A : C} (f g : Subobject A) : (inf.obj f).obj g ≤ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (f g : CategoryTheory.Subobject A)
Goal: (CategoryTheory.Subobject.inf.obj f).obj g ≤ f
-- CategoryTheory.Subobject.inf_le_right
theorem inf_le_right {A : C} (f g : Subobject A) : (inf.obj f).obj g ≤ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (f g : CategoryTheory.Subobject A)
Goal: (CategoryTheory.Subobject.inf.obj f).obj g ≤ g
-- CategoryTheory.Subobject.le_inf
theorem le_inf {A : C} (h f g : Subobject A) : h ≤ f → h ≤ g → h ≤ (inf.obj f).obj g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (h f g : CategoryTheory.Subobject A)
Goal: h ≤ f → h ≤ g → h ≤ (CategoryTheory.Subobject.inf.obj f).obj g
-- CategoryTheory.Subobject.factors_left_of_inf_factors
theorem factors_left_of_inf_factors {A B : C} {X Y : Subobject B} {f : A ⟶ B}
    (h : (X ⊓ Y).Factors f) : X.Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B} (h : (X ⊓ Y).Factors f)
Goal: X.Factors f
-- CategoryTheory.Subobject.factors_right_of_inf_factors
theorem factors_right_of_inf_factors {A B : C} {X Y : Subobject B} {f : A ⟶ B}
    (h : (X ⊓ Y).Factors f) : Y.Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B} (h : (X ⊓ Y).Factors f)
Goal: Y.Factors f
-- CategoryTheory.Subobject.inf_factors
@[simp]
theorem inf_factors {A B : C} {X Y : Subobject B} (f : A ⟶ B) :
    (X ⊓ Y).Factors f ↔ X.Factors f ∧ Y.Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A B : C} {X Y : CategoryTheory.Subobject B} (f : A ⟶ B)
Goal: (X ⊓ Y).Factors f ↔ X.Factors f ∧ Y.Factors f
-- CategoryTheory.Subobject.inf_arrow_factors_left
theorem inf_arrow_factors_left {B : C} (X Y : Subobject B) : X.Factors (X ⊓ Y).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {B : C} (X Y : CategoryTheory.Subobject B)
Goal: X.Factors (X ⊓ Y).arrow
-- CategoryTheory.Subobject.inf_arrow_factors_right
theorem inf_arrow_factors_right {B : C} (X Y : Subobject B) : Y.Factors (X ⊓ Y).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {B : C} (X Y : CategoryTheory.Subobject B)
Goal: Y.Factors (X ⊓ Y).arrow
-- CategoryTheory.Subobject.finset_inf_factors
@[simp]
theorem finset_inf_factors {I : Type*} {A B : C} {s : Finset I} {P : I → Subobject B} (f : A ⟶ B) :
    (s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {I : Type u_1} {A B : C} {s : Finset I} {P : I → CategoryTheory.Subobject B} (f : A ⟶ B)
Goal: (s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f
-- CategoryTheory.Subobject.finset_inf_arrow_factors
theorem finset_inf_arrow_factors {I : Type*} {B : C} (s : Finset I) (P : I → Subobject B) (i : I)
    (m : i ∈ s) : (P i).Factors (s.inf P).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {I : Type u_1} {B : C} (s : Finset I) (P : I → CategoryTheory.Subobject B) (i : I) (m : i ∈ s)
Goal: (P i).Factors (s.inf P).arrow
-- CategoryTheory.Subobject.inf_eq_map_pullback'
theorem inf_eq_map_pullback' {A : C} (f₁ : MonoOver A) (f₂ : Subobject A) :
    (Subobject.inf.obj (Quotient.mk'' f₁)).obj f₂ =
      (Subobject.map f₁.arrow).obj ((Subobject.pullback f₁.arrow).obj f₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (f₁ : CategoryTheory.MonoOver A) (f₂ : CategoryTheory.Subobject A)
Goal: (CategoryTheory.Subobject.inf.obj (Quotient.mk'' f₁)).obj f₂ =
  (CategoryTheory.Subobject.map f₁.arrow).obj ((CategoryTheory.Subobject.pullback f₁.arrow).obj f₂)
-- CategoryTheory.Subobject.inf_eq_map_pullback
theorem inf_eq_map_pullback {A : C} (f₁ : MonoOver A) (f₂ : Subobject A) :
    (Quotient.mk'' f₁ ⊓ f₂ : Subobject A) = (map f₁.arrow).obj ((pullback f₁.arrow).obj f₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (f₁ : CategoryTheory.MonoOver A) (f₂ : CategoryTheory.Subobject A)
Goal: Quotient.mk'' f₁ ⊓ f₂ =
  (CategoryTheory.Subobject.map f₁.arrow).obj ((CategoryTheory.Subobject.pullback f₁.arrow).obj f₂)
-- CategoryTheory.Subobject.prod_eq_inf
theorem prod_eq_inf {A : C} {f₁ f₂ : Subobject A} [HasBinaryProduct f₁ f₂] :
    (f₁ ⨯ f₂) = f₁ ⊓ f₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} {f₁ f₂ : CategoryTheory.Subobject A} [CategoryTheory.Limits.HasBinaryProduct f₁ f₂]
Goal: (f₁ ⨯ f₂) = f₁ ⊓ f₂
-- CategoryTheory.Subobject.inf_def
theorem inf_def {B : C} (m m' : Subobject B) : m ⊓ m' = (inf.obj m).obj m' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {B : C} (m m' : CategoryTheory.Subobject B)
Goal: m ⊓ m' = (CategoryTheory.Subobject.inf.obj m).obj m'
-- CategoryTheory.Subobject.inf_pullback
theorem inf_pullback {X Y : C} (g : X ⟶ Y) (f₁ f₂) :
    (pullback g).obj (f₁ ⊓ f₂) = (pullback g).obj f₁ ⊓ (pullback g).obj f₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (g : X ⟶ Y) (f₁ f₂ : CategoryTheory.Subobject Y)
Goal: (CategoryTheory.Subobject.pullback g).obj (f₁ ⊓ f₂) =
  (CategoryTheory.Subobject.pullback g).obj f₁ ⊓ (CategoryTheory.Subobject.pullback g).obj f₂
-- CategoryTheory.Subobject.inf_map
theorem inf_map {X Y : C} (g : Y ⟶ X) [Mono g] (f₁ f₂) :
    (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (g : Y ⟶ X) [CategoryTheory.Mono g] (f₁ f₂ : CategoryTheory.Subobject Y)
Goal: (CategoryTheory.Subobject.map g).obj (f₁ ⊓ f₂) =
  (CategoryTheory.Subobject.map g).obj f₁ ⊓ (CategoryTheory.Subobject.map g).obj f₂
-- CategoryTheory.Subobject.sup_factors_of_factors_left
theorem sup_factors_of_factors_left {A B : C} {X Y : Subobject B} {f : A ⟶ B} (P : X.Factors f) :
    (X ⊔ Y).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasImages C] [CategoryTheory.Limits.HasBinaryCoproducts C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B} (P : X.Factors f)
Goal: (X ⊔ Y).Factors f
-- CategoryTheory.Subobject.sup_factors_of_factors_right
theorem sup_factors_of_factors_right {A B : C} {X Y : Subobject B} {f : A ⟶ B} (P : Y.Factors f) :
    (X ⊔ Y).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasImages C] [CategoryTheory.Limits.HasBinaryCoproducts C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B} (P : Y.Factors f)
Goal: (X ⊔ Y).Factors f
-- CategoryTheory.Subobject.finset_sup_factors
theorem finset_sup_factors {I : Type*} {A B : C} {s : Finset I} {P : I → Subobject B} {f : A ⟶ B}
    (h : ∃ i ∈ s, (P i).Factors f) : (s.sup P).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasImages C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.InitialMonoClass C] {I : Type u_1} {A B : C} {s : Finset I} {P : I → CategoryTheory.Subobject B} {f : A ⟶ B} (h : ∃ i ∈ s, (P i).Factors f)
Goal: (s.sup P).Factors f
-- CategoryTheory.Subobject.wideCospan_map_term
@[simp]
theorem wideCospan_map_term {A : C} (s : Set (Subobject A)) (j) :
    (wideCospan s).map (WidePullbackShape.Hom.term j) =
      ((equivShrink (Subobject A)).symm j).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] {A : C} (s : Set (CategoryTheory.Subobject A)) (j : ↑(⇑(equivShrink (CategoryTheory.Subobject A)) '' s))
Goal: (CategoryTheory.Subobject.wideCospan s).map (CategoryTheory.Limits.WidePullbackShape.Hom.term j) =
  ((equivShrink (CategoryTheory.Subobject A)).symm ↑j).arrow
-- CategoryTheory.Subobject.leInfCone_π_app_none
@[simp]
theorem leInfCone_π_app_none {A : C} (s : Set (Subobject A)) (f : Subobject A)
    (k : ∀ g ∈ s, f ≤ g) : (leInfCone s f k).π.app none = f.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] {A : C} (s : Set (CategoryTheory.Subobject A)) (f : CategoryTheory.Subobject A) (k : ∀ g ∈ s, f ≤ g)
Goal: (CategoryTheory.Subobject.leInfCone s f k).π.app none = f.arrow
-- CategoryTheory.Subobject.sInf_le
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] [CategoryTheory.Limits.HasWidePullbacks C] {A : C} (s : Set (CategoryTheory.Subobject A)) (f : CategoryTheory.Subobject A) (hf : f ∈ s)
Goal: CategoryTheory.Subobject.sInf s ≤ f
-- CategoryTheory.Subobject.le_sInf
theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] [CategoryTheory.Limits.HasWidePullbacks C] {A : C} (s : Set (CategoryTheory.Subobject A)) (f : CategoryTheory.Subobject A) (k : ∀ g ∈ s, f ≤ g)
Goal: f ≤ CategoryTheory.Subobject.sInf s
-- CategoryTheory.Subobject.le_sSup
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] [CategoryTheory.Limits.HasCoproducts C] [CategoryTheory.Limits.HasImages C] {A : C} (s : Set (CategoryTheory.Subobject A)) (f : CategoryTheory.Subobject A) (hf : f ∈ s)
Goal: f ≤ CategoryTheory.Subobject.sSup s
-- CategoryTheory.Subobject.symm_apply_mem_iff_mem_image
theorem symm_apply_mem_iff_mem_image {α β : Type*} (e : α ≃ β) (s : Set α) (x : β) :
    e.symm x ∈ s ↔ x ∈ e '' s 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α) (x : β)
Goal: e.symm x ∈ s ↔ x ∈ ⇑e '' s
-- CategoryTheory.Subobject.sSup_le
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.WellPowered C] [CategoryTheory.Limits.HasCoproducts C] [CategoryTheory.Limits.HasImages C] {A : C} (s : Set (CategoryTheory.Subobject A)) (f : CategoryTheory.Subobject A) (k : ∀ g ∈ s, g ≤ f)
Goal: CategoryTheory.Subobject.sSup s ≤ f
-- CategoryTheory.Subobject.nontrivial_of_not_isZero
theorem nontrivial_of_not_isZero {X : C} (h : ¬IsZero X) : Nontrivial (Subobject X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroObject C] {X : C} (h : ¬CategoryTheory.Limits.IsZero X)
Goal: Nontrivial (CategoryTheory.Subobject X)
-- CategoryTheory.Functor.sheafPullback_obj
@[simps!]
def Functor.sheafPullback : Sheaf J A ⥤ Sheaf K A 
Arguments: {C : Type v₁} [CategoryTheory.SmallCategory C] {D : Type v₁} [CategoryTheory.SmallCategory D] (G : CategoryTheory.Functor C D) (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [CategoryTheory.ConcreteCategory A] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget A)] [CategoryTheory.Limits.HasColimits A] [CategoryTheory.Limits.HasLimits A] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget A)] [(CategoryTheory.forget A).ReflectsIsomorphisms] (X : CategoryTheory.Sheaf J A)
Goal: (G.sheafPullback A J K).obj X = (CategoryTheory.presheafToSheaf K A).obj (G.op.lan.obj X.val)
-- CategoryTheory.Functor.sheafPullback_map
@[simps!]
def Functor.sheafPullback : Sheaf J A ⥤ Sheaf K A 
Arguments: {C : Type v₁} [CategoryTheory.SmallCategory C] {D : Type v₁} [CategoryTheory.SmallCategory D] (G : CategoryTheory.Functor C D) (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [CategoryTheory.ConcreteCategory A] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget A)] [CategoryTheory.Limits.HasColimits A] [CategoryTheory.Limits.HasLimits A] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget A)] [(CategoryTheory.forget A).ReflectsIsomorphisms]
Goal: ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y),
  (G.sheafPullback A J K).map f = (CategoryTheory.presheafToSheaf K A).map (G.op.lan.map f.val)
-- CategoryTheory.constantSheafAdj_counit_app
lemma constantSheafAdj_counit_app {T : C} (hT : IsTerminal T) (F : Sheaf J D) :
    (constantSheafAdj J D hT).counit.app F =
      (presheafToSheaf J D).map ((constantPresheafAdj D hT).counit.app F.val) ≫
        (sheafificationAdjunction J D).counit.app F 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (D : Type u_2) [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.HasWeakSheafify J D] {T : C} (hT : CategoryTheory.Limits.IsTerminal T) (F : CategoryTheory.Sheaf J D)
Goal: (CategoryTheory.constantSheafAdj J D hT).counit.app F =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.presheafToSheaf J D).map ((CategoryTheory.constantPresheafAdj D hT).counit.app F.val))
    ((CategoryTheory.sheafificationAdjunction J D).counit.app F)
-- IsPurelyInseparable.isIntegral
class IsPurelyInseparable : Prop where
  isIntegral : Algebra.IsIntegral F E
  inseparable' (x : E) : IsSeparable F x → x ∈ (algebraMap F E).range
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] [self : IsPurelyInseparable F E]
Goal: Algebra.IsIntegral F E
-- IsPurelyInseparable.inseparable'
class IsPurelyInseparable : Prop where
  isIntegral : Algebra.IsIntegral F E
  inseparable' (x : E) : IsSeparable F x → x ∈ (algebraMap F E).range
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] [self : IsPurelyInseparable F E] (x : E)
Goal: IsSeparable F x → x ∈ (algebraMap F E).range
-- IsPurelyInseparable.isIntegral'
theorem IsPurelyInseparable.isIntegral' [IsPurelyInseparable F E] (x : E) : IsIntegral F x 
Arguments: (F : Type u) {E : Type v} [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E] (x : E)
Goal: IsIntegral F x
-- IsPurelyInseparable.isAlgebraic
theorem IsPurelyInseparable.isAlgebraic [IsPurelyInseparable F E] :
    Algebra.IsAlgebraic F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E]
Goal: Algebra.IsAlgebraic F E
-- IsPurelyInseparable.inseparable
theorem IsPurelyInseparable.inseparable [IsPurelyInseparable F E] :
    ∀ x : E, IsSeparable F x → x ∈ (algebraMap F E).range 
Arguments: (F : Type u) {E : Type v} [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E] (x : E)
Goal: IsSeparable F x → x ∈ (algebraMap F E).range
-- isPurelyInseparable_iff
theorem isPurelyInseparable_iff : IsPurelyInseparable F E ↔ ∀ x : E,
    IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range) 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E]
Goal: IsPurelyInseparable F E ↔ ∀ (x : E), IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range)
-- AlgEquiv.isPurelyInseparable
theorem AlgEquiv.isPurelyInseparable (e : K ≃ₐ[F] E) [IsPurelyInseparable F K] :
    IsPurelyInseparable F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (e : K ≃ₐ[F] E) [IsPurelyInseparable F K]
Goal: IsPurelyInseparable F E
-- AlgEquiv.isPurelyInseparable_iff
theorem AlgEquiv.isPurelyInseparable_iff (e : K ≃ₐ[F] E) :
    IsPurelyInseparable F K ↔ IsPurelyInseparable F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (e : K ≃ₐ[F] E)
Goal: IsPurelyInseparable F K ↔ IsPurelyInseparable F E
-- Algebra.IsAlgebraic.isPurelyInseparable_of_isSepClosed
theorem Algebra.IsAlgebraic.isPurelyInseparable_of_isSepClosed [Algebra.IsAlgebraic F E]
    [IsSepClosed F] : IsPurelyInseparable F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] [Algebra.IsAlgebraic F E] [IsSepClosed F]
Goal: IsPurelyInseparable F E
-- IsPurelyInseparable.surjective_algebraMap_of_isSeparable
theorem IsPurelyInseparable.surjective_algebraMap_of_isSeparable
    [IsPurelyInseparable F E] [Algebra.IsSeparable F E] : Function.Surjective (algebraMap F E) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E] [Algebra.IsSeparable F E]
Goal: Function.Surjective ⇑(algebraMap F E)
-- IsPurelyInseparable.bijective_algebraMap_of_isSeparable
theorem IsPurelyInseparable.bijective_algebraMap_of_isSeparable
    [IsPurelyInseparable F E] [Algebra.IsSeparable F E] : Function.Bijective (algebraMap F E) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E] [Algebra.IsSeparable F E]
Goal: Function.Bijective ⇑(algebraMap F E)
-- IntermediateField.eq_bot_of_isPurelyInseparable_of_isSeparable
theorem IntermediateField.eq_bot_of_isPurelyInseparable_of_isSeparable (L : IntermediateField F E)
    [IsPurelyInseparable F L] [Algebra.IsSeparable F L] : L = ⊥ 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] (L : IntermediateField F E) [IsPurelyInseparable F ↥L] [Algebra.IsSeparable F ↥L]
Goal: L = ⊥
-- separableClosure.eq_bot_of_isPurelyInseparable
theorem separableClosure.eq_bot_of_isPurelyInseparable [IsPurelyInseparable F E] :
    separableClosure F E = ⊥ 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [IsPurelyInseparable F E]
Goal: separableClosure F E = ⊥
-- separableClosure.eq_bot_iff
theorem separableClosure.eq_bot_iff [Algebra.IsAlgebraic F E] :
    separableClosure F E = ⊥ ↔ IsPurelyInseparable F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] [Algebra.IsAlgebraic F E]
Goal: separableClosure F E = ⊥ ↔ IsPurelyInseparable F E
-- isPurelyInseparable_iff_pow_mem
theorem isPurelyInseparable_iff_pow_mem (q : ℕ) [ExpChar F q] :
    IsPurelyInseparable F E ↔ ∀ x : E, ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range 
Arguments: (F : Type u) {E : Type v} [Field F] [Field E] [Algebra F E] (q : ℕ) [ExpChar F q]
Goal: IsPurelyInseparable F E ↔ ∀ (x : E), ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
-- IsPurelyInseparable.pow_mem
theorem IsPurelyInseparable.pow_mem (q : ℕ) [ExpChar F q] [IsPurelyInseparable F E] (x : E) :
    ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range 
Arguments: (F : Type u) {E : Type v} [Field F] [Field E] [Algebra F E] (q : ℕ) [ExpChar F q] [IsPurelyInseparable F E] (x : E)
Goal: ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
-- mem_perfectClosure_iff
theorem mem_perfectClosure_iff {x : E} :
    x ∈ perfectClosure F E ↔ ∃ n : ℕ, x ^ (ringExpChar F) ^ n ∈ (algebraMap F E).range 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {x : E}
Goal: x ∈ perfectClosure F E ↔ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F E).range
-- mem_perfectClosure_iff_pow_mem
theorem mem_perfectClosure_iff_pow_mem (q : ℕ) [ExpChar F q] {x : E} :
    x ∈ perfectClosure F E ↔ ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] (q : ℕ) [ExpChar F q] {x : E}
Goal: x ∈ perfectClosure F E ↔ ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
-- mem_perfectClosure_iff_natSepDegree_eq_one
theorem mem_perfectClosure_iff_natSepDegree_eq_one {x : E} :
    x ∈ perfectClosure F E ↔ (minpoly F x).natSepDegree = 1 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {x : E}
Goal: x ∈ perfectClosure F E ↔ (minpoly F x).natSepDegree = 1
-- isPurelyInseparable_iff_perfectClosure_eq_top
theorem isPurelyInseparable_iff_perfectClosure_eq_top :
    IsPurelyInseparable F E ↔ perfectClosure F E = ⊤ 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E]
Goal: IsPurelyInseparable F E ↔ perfectClosure F E = ⊤
-- perfectClosure.eq_bot_of_isSeparable
theorem perfectClosure.eq_bot_of_isSeparable [Algebra.IsSeparable F E] : perfectClosure F E = ⊥ 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [Algebra.IsSeparable F E]
Goal: perfectClosure F E = ⊥
-- le_perfectClosure
theorem le_perfectClosure (L : IntermediateField F E) [h : IsPurelyInseparable F L] :
    L ≤ perfectClosure F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (L : IntermediateField F E) [h : IsPurelyInseparable F ↥L]
Goal: L ≤ perfectClosure F E
-- le_perfectClosure_iff
theorem le_perfectClosure_iff (L : IntermediateField F E) :
    L ≤ perfectClosure F E ↔ IsPurelyInseparable F L 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (L : IntermediateField F E)
Goal: L ≤ perfectClosure F E ↔ IsPurelyInseparable F ↥L
-- separableClosure_inf_perfectClosure
theorem separableClosure_inf_perfectClosure : separableClosure F E ⊓ perfectClosure F E = ⊥ 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: separableClosure F E ⊓ perfectClosure F E = ⊥
-- map_mem_perfectClosure_iff
theorem map_mem_perfectClosure_iff (i : E →ₐ[F] K) {x : E} :
    i x ∈ perfectClosure F K ↔ x ∈ perfectClosure F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K) {x : E}
Goal: i x ∈ perfectClosure F K ↔ x ∈ perfectClosure F E
-- perfectClosure.comap_eq_of_algHom
theorem perfectClosure.comap_eq_of_algHom (i : E →ₐ[F] K) :
    (perfectClosure F K).comap i = perfectClosure F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K)
Goal: IntermediateField.comap i (perfectClosure F K) = perfectClosure F E
-- perfectClosure.map_le_of_algHom
theorem perfectClosure.map_le_of_algHom (i : E →ₐ[F] K) :
    (perfectClosure F E).map i ≤ perfectClosure F K 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K)
Goal: IntermediateField.map i (perfectClosure F E) ≤ perfectClosure F K
-- perfectClosure.map_eq_of_algEquiv
theorem perfectClosure.map_eq_of_algEquiv (i : E ≃ₐ[F] K) :
    (perfectClosure F E).map i.toAlgHom = perfectClosure F K 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: IntermediateField.map (↑i) (perfectClosure F E) = perfectClosure F K
-- IsPurelyInseparable.tower_bot
theorem IsPurelyInseparable.tower_bot [Algebra E K] [IsScalarTower F E K]
    [IsPurelyInseparable F K] : IsPurelyInseparable F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K] [IsPurelyInseparable F K]
Goal: IsPurelyInseparable F E