ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GrothendieckTopology.HasSheafCompose.isSheaf
class GrothendieckTopology.HasSheafCompose : Prop where
    isSheaf (P : Cᵒᵖ ⥤ A) (hP : Presheaf.IsSheaf J P) : Presheaf.IsSheaf J (P ⋙ F)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] {J : CategoryTheory.GrothendieckTopology C} {F : CategoryTheory.Functor A B} [self : J.HasSheafCompose F] (P : CategoryTheory.Functor Cᵒᵖ A) (hP : CategoryTheory.Presheaf.IsSheaf J P)
Goal: CategoryTheory.Presheaf.IsSheaf J (P.comp F)
-- CategoryTheory.sheafCompose_map_val
@[simps]
def sheafCompose : Sheaf J A ⥤ Sheaf J B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (F : CategoryTheory.Functor A B) [J.HasSheafCompose F]
Goal: ∀ {X Y : CategoryTheory.Sheaf J A} (η : X ⟶ Y),
  ((CategoryTheory.sheafCompose J F).map η).val = CategoryTheory.whiskerRight η.val F
-- CategoryTheory.sheafCompose_obj_val
@[simps]
def sheafCompose : Sheaf J A ⥤ Sheaf J B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (F : CategoryTheory.Functor A B) [J.HasSheafCompose F] (G : CategoryTheory.Sheaf J A)
Goal: ((CategoryTheory.sheafCompose J F).obj G).val = G.val.comp F
-- CategoryTheory.sheafCompose_id
@[simp]
lemma sheafCompose_id : sheafCompose_map (F := F) J (𝟙 _) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) {F : CategoryTheory.Functor A B} [J.HasSheafCompose F]
Goal: CategoryTheory.sheafCompose_map J (CategoryTheory.CategoryStruct.id F) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.sheafCompose J F)
-- CategoryTheory.sheafCompose_comp
@[simp]
lemma sheafCompose_comp :
    sheafCompose_map J (η ≫ γ) = sheafCompose_map J η ≫ sheafCompose_map J γ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) {F G : CategoryTheory.Functor A B} (H : CategoryTheory.Functor A B) (η : F ⟶ G) (γ : G ⟶ H) [J.HasSheafCompose F] [J.HasSheafCompose G] [J.HasSheafCompose H]
Goal: CategoryTheory.sheafCompose_map J (CategoryTheory.CategoryStruct.comp η γ) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.sheafCompose_map J η) (CategoryTheory.sheafCompose_map J γ)
-- CategoryTheory.GrothendieckTopology.Cover.multicospanComp_hom_app
@[simps!]
def multicospanComp : (S.index (P ⋙ F)).multicospan ≅ (S.index P).multicospan ⋙ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] {J : CategoryTheory.GrothendieckTopology C} (F : CategoryTheory.Functor A B) (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : J.Cover X)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingMulticospan (S.index (P.comp F)).fstTo (S.index (P.comp F)).sndTo),
  (CategoryTheory.GrothendieckTopology.Cover.multicospanComp F P S).hom.app X_1 =
    (match X_1 with
      | CategoryTheory.Limits.WalkingMulticospan.left a => CategoryTheory.Iso.refl (F.obj (P.obj (Opposite.op a.Y)))
      | CategoryTheory.Limits.WalkingMulticospan.right b =>
        CategoryTheory.Iso.refl (F.obj (P.obj (Opposite.op b.r.Z)))).hom
-- CategoryTheory.GrothendieckTopology.Cover.multicospanComp_inv_app
@[simps!]
def multicospanComp : (S.index (P ⋙ F)).multicospan ≅ (S.index P).multicospan ⋙ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] {J : CategoryTheory.GrothendieckTopology C} (F : CategoryTheory.Functor A B) (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : J.Cover X)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingMulticospan (S.index (P.comp F)).fstTo (S.index (P.comp F)).sndTo),
  (CategoryTheory.GrothendieckTopology.Cover.multicospanComp F P S).inv.app X_1 =
    (match X_1 with
      | CategoryTheory.Limits.WalkingMulticospan.left a => CategoryTheory.Iso.refl (F.obj (P.obj (Opposite.op a.Y)))
      | CategoryTheory.Limits.WalkingMulticospan.right b =>
        CategoryTheory.Iso.refl (F.obj (P.obj (Opposite.op b.r.Z)))).inv
-- CategoryTheory.Sheaf.isSeparated
lemma Sheaf.isSeparated [ConcreteCategory A] [J.HasSheafCompose (forget A)]
    (F : Sheaf J A) : Presheaf.IsSeparated J F.val 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.ConcreteCategory A] [J.HasSheafCompose (CategoryTheory.forget A)] (F : CategoryTheory.Sheaf J A)
Goal: CategoryTheory.Presheaf.IsSeparated J F.val
-- CategoryTheory.Presheaf.IsSheaf.isSeparated
lemma Presheaf.IsSheaf.isSeparated {F : Cᵒᵖ ⥤ A} [ConcreteCategory A]
    [J.HasSheafCompose (forget A)] (hF : Presheaf.IsSheaf J F) :
    Presheaf.IsSeparated J F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {F : CategoryTheory.Functor Cᵒᵖ A} [CategoryTheory.ConcreteCategory A] [J.HasSheafCompose (CategoryTheory.forget A)] (hF : CategoryTheory.Presheaf.IsSheaf J F)
Goal: CategoryTheory.Presheaf.IsSeparated J F
-- CategoryTheory.GrothendieckTopology.W_eq_W_range_sheafToPresheaf_obj
lemma W_eq_W_range_sheafToPresheaf_obj :
    J.W = LeftBousfield.W (· ∈ Set.range (sheafToPresheaf J A).obj) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u_2) [CategoryTheory.Category.{u_4, u_2} A]
Goal: J.W = CategoryTheory.Localization.LeftBousfield.W fun x => x ∈ Set.range (CategoryTheory.sheafToPresheaf J A).obj
-- CategoryTheory.GrothendieckTopology.W_sheafToPreheaf_map_iff_isIso
lemma W_sheafToPreheaf_map_iff_isIso {F₁ F₂ : Sheaf J A} (φ : F₁ ⟶ F₂) :
    J.W ((sheafToPresheaf J A).map φ) ↔ IsIso φ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_4, u_2} A] {F₁ F₂ : CategoryTheory.Sheaf J A} (φ : F₁ ⟶ F₂)
Goal: J.W ((CategoryTheory.sheafToPresheaf J A).map φ) ↔ CategoryTheory.IsIso φ
-- CategoryTheory.GrothendieckTopology.W_adj_unit_app
lemma W_adj_unit_app (adj : G ⊣ sheafToPresheaf J A) (P : Cᵒᵖ ⥤ A) : J.W (adj.unit.app P) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_3, u_2} A] {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)} (adj : G ⊣ CategoryTheory.sheafToPresheaf J A) (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: J.W (adj.unit.app P)
-- CategoryTheory.GrothendieckTopology.W_iff_isIso_map_of_adjunction
lemma W_iff_isIso_map_of_adjunction (adj : G ⊣ sheafToPresheaf J A)
    {P₁ P₂ : Cᵒᵖ ⥤ A} (f : P₁ ⟶ P₂) :
    J.W f ↔ IsIso (G.map f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_3, u_2} A] {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)} (adj : G ⊣ CategoryTheory.sheafToPresheaf J A) {P₁ P₂ : CategoryTheory.Functor Cᵒᵖ A} (f : P₁ ⟶ P₂)
Goal: J.W f ↔ CategoryTheory.IsIso (G.map f)
-- CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms_of_adjunction
lemma W_eq_inverseImage_isomorphisms_of_adjunction (adj : G ⊣ sheafToPresheaf J A) :
    J.W = (MorphismProperty.isomorphisms _).inverseImage G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_3, u_2} A] {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)} (adj : G ⊣ CategoryTheory.sheafToPresheaf J A)
Goal: J.W = (CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage G
-- CategoryTheory.GrothendieckTopology.W_toSheafify
lemma W_toSheafify (P : Cᵒᵖ ⥤ A) : J.W (toSheafify J P) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_4, u_2} A] [CategoryTheory.HasWeakSheafify J A] (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: J.W (CategoryTheory.toSheafify J P)
-- CategoryTheory.GrothendieckTopology.W_iff
lemma W_iff {P₁ P₂ : Cᵒᵖ ⥤ A} (f : P₁ ⟶ P₂) :
    J.W f ↔ IsIso ((presheafToSheaf J A).map f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_2} [CategoryTheory.Category.{u_4, u_2} A] [CategoryTheory.HasWeakSheafify J A] {P₁ P₂ : CategoryTheory.Functor Cᵒᵖ A} (f : P₁ ⟶ P₂)
Goal: J.W f ↔ CategoryTheory.IsIso ((CategoryTheory.presheafToSheaf J A).map f)
-- CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms
lemma W_eq_inverseImage_isomorphisms :
    J.W = (MorphismProperty.isomorphisms _).inverseImage (presheafToSheaf J A) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u_2) [CategoryTheory.Category.{u_4, u_2} A] [CategoryTheory.HasWeakSheafify J A]
Goal: J.W =
  (CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage
    (CategoryTheory.presheafToSheaf J A)
-- CategoryTheory.GrothendieckTopology.coversTop_iff_of_isTerminal
lemma coversTop_iff_of_isTerminal (X : C) (hX : IsTerminal X)
    {I : Type*} (Y : I → C) :
    J.CoversTop Y ↔ Sieve.ofObjects Y X ∈ J X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C) (hX : CategoryTheory.Limits.IsTerminal X) {I : Type u_1} (Y : I → C)
Goal: J.CoversTop Y ↔ CategoryTheory.Sieve.ofObjects Y X ∈ J.sieves X
-- CategoryTheory.GrothendieckTopology.CoversTop.ext
lemma ext (F : Sheaf J A) {c : Cone F.1} (hc : IsLimit c) {X : A} {f g : X ⟶ c.pt}
    (h : ∀ (i : I), f ≫ c.π.app (Opposite.op (Y i)) =
      g ≫ c.π.app (Opposite.op (Y i))) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {I : Type u_1} {Y : I → C} (hY : J.CoversTop Y) (F : CategoryTheory.Sheaf J A) {c : CategoryTheory.Limits.Cone F.val} (hc : CategoryTheory.Limits.IsLimit c) {X : A} {f g : X ⟶ c.pt} (h :
  ∀ (i : I),
    CategoryTheory.CategoryStruct.comp f (c.π.app (Opposite.op (Y i))) =
      CategoryTheory.CategoryStruct.comp g (c.π.app (Opposite.op (Y i))))
Goal: f = g
-- CategoryTheory.GrothendieckTopology.CoversTop.sections_ext
lemma sections_ext (F : Sheaf J (Type _)) {x y : F.1.sections}
    (h : ∀ (i : I), x.1 (Opposite.op (Y i)) = y.1 (Opposite.op (Y i))) :
    x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {I : Type u_1} {Y : I → C} (hY : J.CoversTop Y) (F : CategoryTheory.Sheaf J (Type u_2)) {x y : ↑F.val.sections} (h : ∀ (i : I), ↑x (Opposite.op (Y i)) = ↑y (Opposite.op (Y i)))
Goal: x = y
-- CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.familyOfElements_apply
lemma familyOfElements_apply (hx : x.IsCompatible) {X Z : C} (f : Z ⟶ X) (i : I) (φ : Z ⟶ Y i) :
    familyOfElements x X f ⟨i, ⟨φ⟩⟩ = F.map φ.op (x i) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {I : Type u_1} {Y : I → C} {x : CategoryTheory.Presheaf.FamilyOfElementsOnObjects F Y} (hx : x.IsCompatible) {X Z : C} (f : Z ⟶ X) (i : I) (φ : Z ⟶ Y i)
Goal: x.familyOfElements X f ⋯ = F.map φ.op (x i)
-- CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.familyOfElements_isCompatible
lemma familyOfElements_isCompatible (hx : x.IsCompatible) (X : C) :
    (familyOfElements x X).Compatible 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {I : Type u_1} {Y : I → C} {x : CategoryTheory.Presheaf.FamilyOfElementsOnObjects F Y} (hx : x.IsCompatible) (X : C)
Goal: (x.familyOfElements X).Compatible
-- CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.exists_unique_section
lemma exists_unique_section (hx : x.IsCompatible) (hY : J.CoversTop Y) (hF : IsSheaf J F) :
    ∃! (s : F.sections), ∀ (i : I), s.1 (Opposite.op (Y i)) = x i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {I : Type u_1} {Y : I → C} {x : CategoryTheory.Presheaf.FamilyOfElementsOnObjects F Y} (hx : x.IsCompatible) (hY : J.CoversTop Y) (hF : CategoryTheory.Presheaf.IsSheaf J F)
Goal: ∃! s, ∀ (i : I), ↑s (Opposite.op (Y i)) = x i
-- CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.section_apply
@[simp]
lemma section_apply (i : I) : (hx.section_ hY hF).1 (Opposite.op (Y i)) = x i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {I : Type u_1} {Y : I → C} {x : CategoryTheory.Presheaf.FamilyOfElementsOnObjects F Y} (hx : x.IsCompatible) (hY : J.CoversTop Y) (hF : CategoryTheory.Presheaf.IsSheaf J F) (i : I)
Goal: ↑(hx.section_ hY hF) (Opposite.op (Y i)) = x i
-- IntermediateField.mem_adjoin_iff
theorem mem_adjoin_iff (x : E) :
    x ∈ adjoin F S ↔ ∃ r s : MvPolynomial S F,
      x = MvPolynomial.aeval Subtype.val r / MvPolynomial.aeval Subtype.val s 
Arguments: (F : Type u_1) [Field F] {E : Type u_2} [Field E] [Algebra F E] {S : Set E} (x : E)
Goal: x ∈ IntermediateField.adjoin F S ↔ ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s
-- IntermediateField.mem_adjoin_simple_iff
theorem mem_adjoin_simple_iff {α : E} (x : E) :
    x ∈ adjoin F {α} ↔ ∃ r s : F[X], x = aeval α r / aeval α s 
Arguments: (F : Type u_1) [Field F] {E : Type u_2} [Field E] [Algebra F E] {α : E} (x : E)
Goal: x ∈ F⟮α⟯ ↔ ∃ r s, x = (Polynomial.aeval α) r / (Polynomial.aeval α) s
-- IntermediateField.adjoin_le_iff
@[simp]
theorem adjoin_le_iff {S : Set E} {T : IntermediateField F E} : adjoin F S ≤ T ↔ S ≤ T 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {S : Set E} {T : IntermediateField F E}
Goal: IntermediateField.adjoin F S ≤ T ↔ S ≤ ↑T
-- IntermediateField.gc
theorem gc : GaloisConnection (adjoin F : Set E → IntermediateField F E)
    (fun (x : IntermediateField F E) => (x : Set E)) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: GaloisConnection (IntermediateField.adjoin F) fun x => ↑x
-- IntermediateField.coe_bot
theorem coe_bot : ↑(⊥ : IntermediateField F E) = Set.range (algebraMap F E) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ↑⊥ = Set.range ⇑(algebraMap F E)
-- IntermediateField.mem_bot
theorem mem_bot {x : E} : x ∈ (⊥ : IntermediateField F E) ↔ x ∈ Set.range (algebraMap F E) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {x : E}
Goal: x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap F E)
-- IntermediateField.bot_toSubalgebra
@[simp]
theorem bot_toSubalgebra : (⊥ : IntermediateField F E).toSubalgebra = ⊥ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ⊥.toSubalgebra = ⊥
-- IntermediateField.coe_top
@[simp]
theorem coe_top : ↑(⊤ : IntermediateField F E) = (Set.univ : Set E) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ↑⊤ = Set.univ
-- IntermediateField.mem_top
@[simp]
theorem mem_top {x : E} : x ∈ (⊤ : IntermediateField F E) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {x : E}
Goal: x ∈ ⊤
-- IntermediateField.top_toSubalgebra
@[simp]
theorem top_toSubalgebra : (⊤ : IntermediateField F E).toSubalgebra = ⊤ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ⊤.toSubalgebra = ⊤
-- IntermediateField.top_toSubfield
@[simp]
theorem top_toSubfield : (⊤ : IntermediateField F E).toSubfield = ⊤ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ⊤.toSubfield = ⊤
-- IntermediateField.coe_inf
@[simp, norm_cast]
theorem coe_inf (S T : IntermediateField F E) : (↑(S ⊓ T) : Set E) = (S : Set E) ∩ T 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S T : IntermediateField F E)
Goal: ↑(S ⊓ T) = ↑S ∩ ↑T
-- IntermediateField.mem_inf
@[simp]
theorem mem_inf {S T : IntermediateField F E} {x : E} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {S T : IntermediateField F E} {x : E}
Goal: x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T
-- IntermediateField.inf_toSubalgebra
@[simp]
theorem inf_toSubalgebra (S T : IntermediateField F E) :
    (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S T : IntermediateField F E)
Goal: (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra
-- IntermediateField.inf_toSubfield
@[simp]
theorem inf_toSubfield (S T : IntermediateField F E) :
    (S ⊓ T).toSubfield = S.toSubfield ⊓ T.toSubfield 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S T : IntermediateField F E)
Goal: (S ⊓ T).toSubfield = S.toSubfield ⊓ T.toSubfield
-- IntermediateField.coe_sInf
@[simp, norm_cast]
theorem coe_sInf (S : Set (IntermediateField F E)) : (↑(sInf S) : Set E) =
    sInf ((fun (x : IntermediateField F E) => (x : Set E)) '' S) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S : Set (IntermediateField F E))
Goal: ↑(sInf S) = sInf ((fun x => ↑x) '' S)
-- IntermediateField.sInf_toSubalgebra
@[simp]
theorem sInf_toSubalgebra (S : Set (IntermediateField F E)) :
    (sInf S).toSubalgebra = sInf (toSubalgebra '' S) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S : Set (IntermediateField F E))
Goal: (sInf S).toSubalgebra = sInf (IntermediateField.toSubalgebra '' S)
-- IntermediateField.sInf_toSubfield
@[simp]
theorem sInf_toSubfield (S : Set (IntermediateField F E)) :
    (sInf S).toSubfield = sInf (toSubfield '' S) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S : Set (IntermediateField F E))
Goal: (sInf S).toSubfield = sInf (IntermediateField.toSubfield '' S)
-- IntermediateField.coe_iInf
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} (S : ι → IntermediateField F E) : (↑(iInf S) : Set E) = ⋂ i, S i 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {ι : Sort u_3} (S : ι → IntermediateField F E)
Goal: ↑(iInf S) = ⋂ i, ↑(S i)
-- IntermediateField.iInf_toSubalgebra
@[simp]
theorem iInf_toSubalgebra {ι : Sort*} (S : ι → IntermediateField F E) :
    (iInf S).toSubalgebra = ⨅ i, (S i).toSubalgebra 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {ι : Sort u_3} (S : ι → IntermediateField F E)
Goal: (iInf S).toSubalgebra = ⨅ i, (S i).toSubalgebra
-- IntermediateField.iInf_toSubfield
@[simp]
theorem iInf_toSubfield {ι : Sort*} (S : ι → IntermediateField F E) :
    (iInf S).toSubfield = ⨅ i, (S i).toSubfield 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {ι : Sort u_3} (S : ι → IntermediateField F E)
Goal: (iInf S).toSubfield = ⨅ i, (S i).toSubfield
-- IntermediateField.equivOfEq_apply
@[simps! apply]
def equivOfEq {S T : IntermediateField F E} (h : S = T) : S ≃ₐ[F] T 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {S T : IntermediateField F E} (h : S = T) (x : ↥S.toSubalgebra)
Goal: (IntermediateField.equivOfEq h) x = ⟨↑x, ⋯⟩
-- IntermediateField.equivOfEq_symm
@[simp]
theorem equivOfEq_symm {S T : IntermediateField F E} (h : S = T) :
    (equivOfEq h).symm = equivOfEq h.symm 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {S T : IntermediateField F E} (h : S = T)
Goal: (IntermediateField.equivOfEq h).symm = IntermediateField.equivOfEq ⋯
-- IntermediateField.equivOfEq_rfl
@[simp]
theorem equivOfEq_rfl (S : IntermediateField F E) : equivOfEq (rfl : S = S) = AlgEquiv.refl 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (S : IntermediateField F E)
Goal: IntermediateField.equivOfEq ⋯ = AlgEquiv.refl
-- IntermediateField.equivOfEq_trans
@[simp]
theorem equivOfEq_trans {S T U : IntermediateField F E} (hST : S = T) (hTU : T = U) :
    (equivOfEq hST).trans (equivOfEq hTU) = equivOfEq (hST.trans hTU) 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {S T U : IntermediateField F E} (hST : S = T) (hTU : T = U)
Goal: (IntermediateField.equivOfEq hST).trans (IntermediateField.equivOfEq hTU) = IntermediateField.equivOfEq ⋯
-- IntermediateField.botEquiv_def
theorem botEquiv_def (x : F) : botEquiv F E (algebraMap F (⊥ : IntermediateField F E) x) = x 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (x : F)
Goal: (IntermediateField.botEquiv F E) ((algebraMap F ↥⊥) x) = x
-- IntermediateField.botEquiv_symm
@[simp]
theorem botEquiv_symm (x : F) : (botEquiv F E).symm x = algebraMap F _ x 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (x : F)
Goal: (IntermediateField.botEquiv F E).symm x = (algebraMap F ↥⊥) x
-- IntermediateField.coe_algebraMap_over_bot
theorem coe_algebraMap_over_bot :
    (algebraMap (⊥ : IntermediateField F E) F : (⊥ : IntermediateField F E) → F) =
      IntermediateField.botEquiv F E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E)
-- IntermediateField.topEquiv_symm_apply_coe
@[simps!]
def topEquiv : (⊤ : IntermediateField F E) ≃ₐ[F] E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ∀ (a : E), ↑(IntermediateField.topEquiv.symm a) = ↑((↑↑Subalgebra.topEquiv).symm a)
-- IntermediateField.topEquiv_apply
@[simps!]
def topEquiv : (⊤ : IntermediateField F E) ≃ₐ[F] E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: ∀ (a : ↥⊤.toSubalgebra), IntermediateField.topEquiv a = ↑a
-- IntermediateField.restrictScalars_bot_eq_self
@[simp]
theorem restrictScalars_bot_eq_self (K : IntermediateField F E) :
    (⊥ : IntermediateField K E).restrictScalars _ = K 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (K : IntermediateField F E)
Goal: IntermediateField.restrictScalars F ⊥ = K
-- IntermediateField.restrictScalars_top
@[simp]
theorem restrictScalars_top {K : Type*} [Field K] [Algebra K E] [Algebra K F]
    [IsScalarTower K F E] : (⊤ : IntermediateField F E).restrictScalars K = ⊤ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {K : Type u_3} [Field K] [Algebra K E] [Algebra K F] [IsScalarTower K F E]
Goal: IntermediateField.restrictScalars K ⊤ = ⊤
-- IntermediateField.map_bot
@[simp]
theorem map_bot (f : E →ₐ[F] K) :
    IntermediateField.map f ⊥ = ⊥ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {K : Type u_3} [Field K] [Algebra F K] (f : E →ₐ[F] K)
Goal: IntermediateField.map f ⊥ = ⊥
-- IntermediateField.map_sup
theorem map_sup (s t : IntermediateField F E) (f : E →ₐ[F] K) : (s ⊔ t).map f = s.map f ⊔ t.map f 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {K : Type u_3} [Field K] [Algebra F K] (s t : IntermediateField F E) (f : E →ₐ[F] K)
Goal: IntermediateField.map f (s ⊔ t) = IntermediateField.map f s ⊔ IntermediateField.map f t
-- IntermediateField.map_iSup
theorem map_iSup {ι : Sort*} (f : E →ₐ[F] K) (s : ι → IntermediateField F E) :
    (iSup s).map f = ⨆ i, (s i).map f 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {K : Type u_3} [Field K] [Algebra F K] {ι : Sort u_4} (f : E →ₐ[F] K) (s : ι → IntermediateField F E)
Goal: IntermediateField.map f (iSup s) = ⨆ i, IntermediateField.map f (s i)