ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Action.FunctorCategoryEquivalence.counitIso_inv_app_app
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (SingleObj G ⥤ V) 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} (X : CategoryTheory.SingleObj ↑G ⥤ V)
Goal: ∀ (X_1 : CategoryTheory.SingleObj ↑G),
  (Action.FunctorCategoryEquivalence.counitIso.inv.app X).app X_1 = 𝟙 (X.obj PUnit.unit)
-- Action.FunctorCategoryEquivalence.counitIso_hom_app_app
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (SingleObj G ⥤ V) 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} (X : CategoryTheory.SingleObj ↑G ⥤ V)
Goal: ∀ (X_1 : CategoryTheory.SingleObj ↑G),
  (Action.FunctorCategoryEquivalence.counitIso.hom.app X).app X_1 = 𝟙 (X.obj PUnit.unit)
-- Action.functorCategoryEquivalence_functor
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat)
Goal: (Action.functorCategoryEquivalence V G).functor = Action.FunctorCategoryEquivalence.functor
-- Action.functorCategoryEquivalence_inverse
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat)
Goal: (Action.functorCategoryEquivalence V G).inverse = Action.FunctorCategoryEquivalence.inverse
-- Action.functorCategoryEquivalence_counitIso
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat)
Goal: (Action.functorCategoryEquivalence V G).counitIso = Action.FunctorCategoryEquivalence.counitIso
-- Action.functorCategoryEquivalence_unitIso
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat)
Goal: (Action.functorCategoryEquivalence V G).unitIso = Action.FunctorCategoryEquivalence.unitIso
-- Action.forget_obj
@[simps]
def forget : Action V G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) (M : Action V G)
Goal: (Action.forget V G).obj M = M.V
-- Action.forget_map
@[simps]
def forget : Action V G ⥤ V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat)
Goal: ∀ {X Y : Action V G} (f : X ⟶ Y), (Action.forget V G).map f = f.hom
-- Action.Iso.conj_ρ
theorem Iso.conj_ρ {M N : Action V G} (f : M ≅ N) (g : G) :
    N.ρ g = ((forget V G).mapIso f).conj (M.ρ g) 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} {M N : Action V G} (f : M ≅ N) (g : ↑G)
Goal: N.ρ g = ((Action.forget V G).mapIso f).conj (M.ρ g)
-- Action.res_obj_V
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G H : MonCat} (f : G ⟶ H) (M : Action V H)
Goal: ((Action.res V f).obj M).V = M.V
-- Action.res_map_hom
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G H : MonCat} (f : G ⟶ H)
Goal: ∀ {X Y : Action V H} (p : X ⟶ Y), ((Action.res V f).map p).hom = p.hom
-- Action.res_obj_ρ
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G H : MonCat} (f : G ⟶ H) (M : Action V H)
Goal: ((Action.res V f).obj M).ρ = f ≫ M.ρ
-- Action.resId_inv_app_hom
@[simps!]
def resId {G : MonCat} : res V (𝟙 G) ≅ 𝟭 (Action V G) 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G : MonCat} (X : Action V G)
Goal: ((Action.resId V).inv.app X).hom = 𝟙 X.V
-- Action.resId_hom_app_hom
@[simps!]
def resId {G : MonCat} : res V (𝟙 G) ≅ 𝟭 (Action V G) 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G : MonCat} (X : Action V G)
Goal: ((Action.resId V).hom.app X).hom = 𝟙 X.V
-- Action.resComp_inv_app_hom
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g) 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) (X : Action V K)
Goal: ((Action.resComp V f g).inv.app X).hom = 𝟙 X.V
-- Action.resComp_hom_app_hom
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g) 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) (X : Action V K)
Goal: ((Action.resComp V f g).hom.app X).hom = 𝟙 X.V
-- CategoryTheory.Functor.mapAction_map_hom
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {W : Type (u + 1)} [CategoryTheory.LargeCategory W] (F : V ⥤ W) (G : MonCat)
Goal: ∀ {X Y : Action V G} (f : X ⟶ Y), ((F.mapAction G).map f).hom = F.map f.hom
-- CategoryTheory.Functor.mapAction_obj_ρ_apply
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {W : Type (u + 1)} [CategoryTheory.LargeCategory W] (F : V ⥤ W) (G : MonCat) (M : Action V G) (g : ↑G)
Goal: ((F.mapAction G).obj M).ρ g = F.map (M.ρ g)
-- CategoryTheory.Functor.mapAction_obj_V
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {W : Type (u + 1)} [CategoryTheory.LargeCategory W] (F : V ⥤ W) (G : MonCat) (M : Action V G)
Goal: ((F.mapAction G).obj M).V = F.obj M.V
-- isCyclotomicExtension_iff

@[mk_iff]
class IsCyclotomicExtension : Prop where
    exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
    adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B]
Goal: IsCyclotomicExtension S A B ↔
  (∀ {n : ℕ+}, n ∈ S → ∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1}
-- IsCyclotomicExtension.exists_prim_root

@[mk_iff]
class IsCyclotomicExtension : Prop where
    exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
    adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
Arguments: {S : Set ℕ+} (A : Type u) {B : Type v} [CommRing A] [CommRing B] [Algebra A B] [self : IsCyclotomicExtension S A B] {n : ℕ+} (ha : n ∈ S)
Goal: ∃ r, IsPrimitiveRoot r ↑n
-- IsCyclotomicExtension.adjoin_roots

@[mk_iff]
class IsCyclotomicExtension : Prop where
    exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
    adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
Arguments: {S : Set ℕ+} {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] [self : IsCyclotomicExtension S A B] (x : B)
Goal: x ∈ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1}
-- IsCyclotomicExtension.iff_adjoin_eq_top
theorem iff_adjoin_eq_top :
    IsCyclotomicExtension S A B ↔
      (∀ n : ℕ+, n ∈ S → ∃ r : B, IsPrimitiveRoot r n) ∧
        adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1} = ⊤ 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B]
Goal: IsCyclotomicExtension S A B ↔ (∀ n ∈ S, ∃ r, IsPrimitiveRoot r ↑n) ∧ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1} = ⊤
-- IsCyclotomicExtension.iff_singleton
theorem iff_singleton :
    IsCyclotomicExtension {n} A B ↔
      (∃ r : B, IsPrimitiveRoot r n) ∧ ∀ x, x ∈ adjoin A {b : B | b ^ (n : ℕ) = 1} 
Arguments: (n : ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B]
Goal: IsCyclotomicExtension {n} A B ↔ (∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ Algebra.adjoin A {b | b ^ ↑n = 1}
-- IsCyclotomicExtension.empty
theorem empty [h : IsCyclotomicExtension ∅ A B] : (⊥ : Subalgebra A B) = ⊤ 
Arguments: (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [h : IsCyclotomicExtension ∅ A B]
Goal: ⊥ = ⊤
-- IsCyclotomicExtension.singleton_one
theorem singleton_one [h : IsCyclotomicExtension {1} A B] : (⊥ : Subalgebra A B) = ⊤ 
Arguments: (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [h : IsCyclotomicExtension {1} A B]
Goal: ⊥ = ⊤
-- IsCyclotomicExtension.singleton_zero_of_bot_eq_top
theorem singleton_zero_of_bot_eq_top (h : (⊥ : Subalgebra A B) = ⊤) :
    IsCyclotomicExtension ∅ A B 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] (h : ⊥ = ⊤)
Goal: IsCyclotomicExtension ∅ A B
-- IsCyclotomicExtension.trans
theorem trans (C : Type w) [CommRing C] [Algebra A C] [Algebra B C] [IsScalarTower A B C]
    [hS : IsCyclotomicExtension S A B] [hT : IsCyclotomicExtension T B C]
    (h : Function.Injective (algebraMap B C)) : IsCyclotomicExtension (S ∪ T) A C 
Arguments: (S T : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] (C : Type w) [CommRing C] [Algebra A C] [Algebra B C] [IsScalarTower A B C] [hS : IsCyclotomicExtension S A B] [hT : IsCyclotomicExtension T B C] (h : Function.Injective ⇑(algebraMap B C))
Goal: IsCyclotomicExtension (S ∪ T) A C
-- IsCyclotomicExtension.subsingleton_iff
@[nontriviality]
theorem subsingleton_iff [Subsingleton B] : IsCyclotomicExtension S A B ↔ S = { } ∨ S = {1} 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [Subsingleton B]
Goal: IsCyclotomicExtension S A B ↔ S = ∅ ∨ S = {1}
-- IsCyclotomicExtension.union_right
theorem union_right [h : IsCyclotomicExtension (S ∪ T) A B] :
    IsCyclotomicExtension T (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1}) B 
Arguments: (S T : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [h : IsCyclotomicExtension (S ∪ T) A B]
Goal: IsCyclotomicExtension T (↥(Algebra.adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1})) B
-- IsCyclotomicExtension.union_left
theorem union_left [h : IsCyclotomicExtension T A B] (hS : S ⊆ T) :
    IsCyclotomicExtension S A (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1}) 
Arguments: (S T : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [h : IsCyclotomicExtension T A B] (hS : S ⊆ T)
Goal: IsCyclotomicExtension S A ↥(Algebra.adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1})
-- IsCyclotomicExtension.of_union_of_dvd
theorem of_union_of_dvd (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty) [H : IsCyclotomicExtension S A B] :
    IsCyclotomicExtension (S ∪ {n}) A B 
Arguments: {n : ℕ+} {S : Set ℕ+} (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty) [H : IsCyclotomicExtension S A B]
Goal: IsCyclotomicExtension (S ∪ {n}) A B
-- IsCyclotomicExtension.iff_union_of_dvd
theorem iff_union_of_dvd (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty) :
    IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {n}) A B 
Arguments: {n : ℕ+} {S : Set ℕ+} (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty)
Goal: IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {n}) A B
-- IsCyclotomicExtension.iff_union_singleton_one
theorem iff_union_singleton_one :
    IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {1}) A B 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B]
Goal: IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {1}) A B
-- IsCyclotomicExtension.singleton_one_of_bot_eq_top
theorem singleton_one_of_bot_eq_top (h : (⊥ : Subalgebra A B) = ⊤) :
    IsCyclotomicExtension {1} A B 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] (h : ⊥ = ⊤)
Goal: IsCyclotomicExtension {1} A B
-- IsCyclotomicExtension.singleton_one_of_algebraMap_bijective
theorem singleton_one_of_algebraMap_bijective (h : Function.Surjective (algebraMap A B)) :
    IsCyclotomicExtension {1} A B 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] (h : Function.Surjective ⇑(algebraMap A B))
Goal: IsCyclotomicExtension {1} A B
-- IsCyclotomicExtension.equiv
protected
theorem equiv {C : Type*} [CommRing C] [Algebra A C] [h : IsCyclotomicExtension S A B]
    (f : B ≃ₐ[A] C) : IsCyclotomicExtension S A C 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] {C : Type u_1} [CommRing C] [Algebra A C] [h : IsCyclotomicExtension S A B] (f : B ≃ₐ[A] C)
Goal: IsCyclotomicExtension S A C
-- IsCyclotomicExtension.neZero
protected
theorem neZero [h : IsCyclotomicExtension {n} A B] [IsDomain B] : NeZero ((n : ℕ) : B) 
Arguments: (n : ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [h : IsCyclotomicExtension {n} A B] [IsDomain B]
Goal: NeZero ↑↑n
-- IsCyclotomicExtension.neZero'
protected
theorem neZero' [IsCyclotomicExtension {n} A B] [IsDomain B] : NeZero ((n : ℕ) : A) 
Arguments: (n : ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [IsCyclotomicExtension {n} A B] [IsDomain B]
Goal: NeZero ↑↑n
-- IsCyclotomicExtension.finite_of_singleton
theorem finite_of_singleton [IsDomain B] [h : IsCyclotomicExtension {n} A B] :
    Module.Finite A B 
Arguments: (n : ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [IsDomain B] [h : IsCyclotomicExtension {n} A B]
Goal: Module.Finite A B
-- IsCyclotomicExtension.finite
protected theorem finite [IsDomain B] [h₁ : Finite S] [h₂ : IsCyclotomicExtension S A B] :
    Module.Finite A B 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [IsDomain B] [h₁ : Finite ↑S] [h₂ : IsCyclotomicExtension S A B]
Goal: Module.Finite A B
-- IsCyclotomicExtension.numberField
theorem numberField [h : NumberField K] [Finite S] [IsCyclotomicExtension S K L] : NumberField L 
Arguments: (S : Set ℕ+) (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [h : NumberField K] [Finite ↑S] [IsCyclotomicExtension S K L]
Goal: NumberField L
-- IsCyclotomicExtension.integral
theorem integral [IsDomain B] [IsNoetherianRing A] [Finite S] [IsCyclotomicExtension S A B] :
    Algebra.IsIntegral A B 
Arguments: (S : Set ℕ+) (A : Type u) (B : Type v) [CommRing A] [CommRing B] [Algebra A B] [IsDomain B] [IsNoetherianRing A] [Finite ↑S] [IsCyclotomicExtension S A B]
Goal: Algebra.IsIntegral A B
-- IsCyclotomicExtension.finiteDimensional
theorem finiteDimensional (C : Type z) [Finite S] [CommRing C] [Algebra K C] [IsDomain C]
    [IsCyclotomicExtension S K C] : FiniteDimensional K C 
Arguments: (S : Set ℕ+) (K : Type w) [Field K] (C : Type z) [Finite ↑S] [CommRing C] [Algebra K C] [IsDomain C] [IsCyclotomicExtension S K C]
Goal: FiniteDimensional K C
-- IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots
theorem adjoin_roots_cyclotomic_eq_adjoin_nth_roots [IsDomain B] {ζ : B} {n : ℕ+}
    (hζ : IsPrimitiveRoot ζ n) :
    adjoin A ((cyclotomic n A).rootSet B) =
      adjoin A {b : B | ∃ a : ℕ+, a ∈ ({n} : Set ℕ+) ∧ b ^ (a : ℕ) = 1} 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] [IsDomain B] {ζ : B} {n : ℕ+} (hζ : IsPrimitiveRoot ζ ↑n)
Goal: Algebra.adjoin A ((Polynomial.cyclotomic (↑n) A).rootSet B) = Algebra.adjoin A {b | ∃ a ∈ {n}, b ^ ↑a = 1}
-- IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic
theorem adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic {n : ℕ+} [IsDomain B] {ζ : B}
    (hζ : IsPrimitiveRoot ζ n) : adjoin A ((cyclotomic n A).rootSet B) = adjoin A {ζ} 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] {n : ℕ+} [IsDomain B] {ζ : B} (hζ : IsPrimitiveRoot ζ ↑n)
Goal: Algebra.adjoin A ((Polynomial.cyclotomic (↑n) A).rootSet B) = Algebra.adjoin A {ζ}
-- IsCyclotomicExtension.adjoin_primitive_root_eq_top
theorem adjoin_primitive_root_eq_top {n : ℕ+} [IsDomain B] [h : IsCyclotomicExtension {n} A B]
    {ζ : B} (hζ : IsPrimitiveRoot ζ n) : adjoin A ({ζ} : Set B) = ⊤ 
Arguments: {A : Type u} {B : Type v} [CommRing A] [CommRing B] [Algebra A B] {n : ℕ+} [IsDomain B] [h : IsCyclotomicExtension {n} A B] {ζ : B} (hζ : IsPrimitiveRoot ζ ↑n)
Goal: Algebra.adjoin A {ζ} = ⊤
-- IsPrimitiveRoot.adjoin_isCyclotomicExtension
theorem _root_.IsPrimitiveRoot.adjoin_isCyclotomicExtension {ζ : B} {n : ℕ+}
    (h : IsPrimitiveRoot ζ n) : IsCyclotomicExtension {n} A (adjoin A ({ζ} : Set B)) 
Arguments: (A : Type u) {B : Type v} [CommRing A] [CommRing B] [Algebra A B] {ζ : B} {n : ℕ+} (h : IsPrimitiveRoot ζ ↑n)
Goal: IsCyclotomicExtension {n} A ↥(Algebra.adjoin A {ζ})
-- IsCyclotomicExtension.splits_X_pow_sub_one
theorem splits_X_pow_sub_one [H : IsCyclotomicExtension S K L] (hS : n ∈ S) :
    Splits (algebraMap K L) (X ^ (n : ℕ) - 1) 
Arguments: {n : ℕ+} {S : Set ℕ+} (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [H : IsCyclotomicExtension S K L] (hS : n ∈ S)
Goal: Polynomial.Splits (algebraMap K L) (Polynomial.X ^ ↑n - 1)
-- IsCyclotomicExtension.splits_cyclotomic
theorem splits_cyclotomic [IsCyclotomicExtension S K L] (hS : n ∈ S) :
    Splits (algebraMap K L) (cyclotomic n K) 
Arguments: {n : ℕ+} {S : Set ℕ+} (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [IsCyclotomicExtension S K L] (hS : n ∈ S)
Goal: Polynomial.Splits (algebraMap K L) (Polynomial.cyclotomic (↑n) K)
-- IsCyclotomicExtension.isSplittingField_X_pow_sub_one
theorem isSplittingField_X_pow_sub_one : IsSplittingField K L (X ^ (n : ℕ) - 1) 
Arguments: (n : ℕ+) (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [IsCyclotomicExtension {n} K L]
Goal: Polynomial.IsSplittingField K L (Polynomial.X ^ ↑n - 1)
-- IsCyclotomicExtension.isGalois
theorem isGalois : IsGalois K L 
Arguments: (n : ℕ+) (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [IsCyclotomicExtension {n} K L]
Goal: IsGalois K L
-- IsCyclotomicExtension.splitting_field_cyclotomic
theorem splitting_field_cyclotomic : IsSplittingField K L (cyclotomic n K) 
Arguments: (n : ℕ+) (K : Type w) (L : Type z) [Field K] [Field L] [Algebra K L] [IsCyclotomicExtension {n} K L]
Goal: Polynomial.IsSplittingField K L (Polynomial.cyclotomic (↑n) K)
-- CyclotomicRing.algebraBase_injective
theorem algebraBase_injective : Function.Injective <| algebraMap A (CyclotomicRing n A K) 
Arguments: (n : ℕ+) (A : Type u) (K : Type w) [CommRing A] [Field K] [Algebra A K] [IsFractionRing A K]
Goal: Function.Injective ⇑(algebraMap A (CyclotomicRing n A K))
-- CyclotomicRing.adjoin_algebra_injective
theorem adjoin_algebra_injective :
    Function.Injective <| algebraMap (CyclotomicRing n A K) (CyclotomicField n K) 
Arguments: (n : ℕ+) (A : Type u) (K : Type w) [CommRing A] [Field K] [Algebra A K]
Goal: Function.Injective ⇑(algebraMap (CyclotomicRing n A K) (CyclotomicField n K))
-- CyclotomicRing.eq_adjoin_primitive_root
theorem eq_adjoin_primitive_root {μ : CyclotomicField n K} (h : IsPrimitiveRoot μ n) :
    CyclotomicRing n A K = adjoin A ({μ} : Set (CyclotomicField n K)) 
Arguments: (n : ℕ+) (A : Type u) (K : Type w) [CommRing A] [Field K] [Algebra A K] {μ : CyclotomicField n K} (h : IsPrimitiveRoot μ ↑n)
Goal: CyclotomicRing n A K = ↥(Algebra.adjoin A {μ})
-- IsAlgClosed.isCyclotomicExtension
theorem IsAlgClosed.isCyclotomicExtension (h : ∀ a ∈ S, NeZero ((a : ℕ) : K)) :
    IsCyclotomicExtension S K K 
Arguments: (S : Set ℕ+) (K : Type w) [Field K] [IsAlgClosed K] (h : ∀ a ∈ S, NeZero ↑↑a)
Goal: IsCyclotomicExtension S K K
-- FirstOrder.Sequence₂.lift_mk
@[simp]
theorem lift_mk {i : ℕ} :
    Cardinal.lift.{v,u} #(Sequence₂ a₀ a₁ a₂ i)
      = #(Sequence₂ (ULift.{v,u} a₀) (ULift.{v,u} a₁) (ULift.{v,u} a₂) i) 
Arguments: (a₀ a₁ a₂ : Type u) {i : ℕ}
Goal: Cardinal.lift.{v, u} #(FirstOrder.Sequence₂ a₀ a₁ a₂ i) =
  #(FirstOrder.Sequence₂ (ULift.{v, u} a₀) (ULift.{v, u} a₁) (ULift.{v, u} a₂) i)
-- FirstOrder.Sequence₂.sum_card
@[simp]
theorem sum_card : Cardinal.sum (fun i => #(Sequence₂ a₀ a₁ a₂ i)) = #a₀ + #a₁ + #a₂ 
Arguments: (a₀ a₁ a₂ : Type u)
Goal: (Cardinal.sum fun i => #(FirstOrder.Sequence₂ a₀ a₁ a₂ i)) = #a₀ + #a₁ + #a₂
-- FirstOrder.Language.mk₂_Functions
@[simps]
protected def mk₂ (c f₁ f₂ : Type u) (r₁ r₂ : Type v) : Language 
Arguments: (c f₁ f₂ : Type u) (r₁ r₂ : Type v)
Goal: ∀ (a : ℕ), (FirstOrder.Language.mk₂ c f₁ f₂ r₁ r₂).Functions a = FirstOrder.Sequence₂ c f₁ f₂ a
-- FirstOrder.Language.mk₂_Relations
@[simps]
protected def mk₂ (c f₁ f₂ : Type u) (r₁ r₂ : Type v) : Language 
Arguments: (c f₁ f₂ : Type u) (r₁ r₂ : Type v)
Goal: ∀ (a : ℕ), (FirstOrder.Language.mk₂ c f₁ f₂ r₁ r₂).Relations a = FirstOrder.Sequence₂ PEmpty.{v + 1} r₁ r₂ a
-- FirstOrder.Language.constants_mk₂
@[simp]
theorem constants_mk₂ (c f₁ f₂ : Type u) (r₁ r₂ : Type v) :
    (Language.mk₂ c f₁ f₂ r₁ r₂).Constants = c 
Arguments: (c f₁ f₂ : Type u) (r₁ r₂ : Type v)
Goal: (FirstOrder.Language.mk₂ c f₁ f₂ r₁ r₂).Constants = c
-- FirstOrder.Language.IsRelational.empty_functions
class IsRelational : Prop where
    empty_functions : ∀ n, IsEmpty (L.Functions n)
Arguments: {L : FirstOrder.Language} [self : L.IsRelational] (n : ℕ)
Goal: IsEmpty (L.Functions n)
-- FirstOrder.Language.IsAlgebraic.empty_relations
class IsAlgebraic : Prop where
    empty_relations : ∀ n, IsEmpty (L.Relations n)
Arguments: {L : FirstOrder.Language} [self : L.IsAlgebraic] (n : ℕ)
Goal: IsEmpty (L.Relations n)
-- FirstOrder.Language.card_eq_card_functions_add_card_relations
theorem card_eq_card_functions_add_card_relations :
    L.card =
      (Cardinal.sum fun l => Cardinal.lift.{v} #(L.Functions l)) +
        Cardinal.sum fun l => Cardinal.lift.{u} #(L.Relations l) 
Arguments: {L : FirstOrder.Language}
Goal: L.card =
  (Cardinal.sum fun l => Cardinal.lift.{v, u} #(L.Functions l)) +
    Cardinal.sum fun l => Cardinal.lift.{u, v} #(L.Relations l)
-- FirstOrder.Language.empty_card
@[simp]
theorem empty_card : Language.empty.card = 0 
Goal: FirstOrder.Language.empty.card = 0
-- FirstOrder.Language.card_functions_sum
@[simp]
theorem card_functions_sum (i : ℕ) :
    #((L.sum L').Functions i)
      = (Cardinal.lift.{u'} #(L.Functions i) + Cardinal.lift.{u} #(L'.Functions i) : Cardinal) 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (i : ℕ)
Goal: #((L.sum L').Functions i) = Cardinal.lift.{u', u} #(L.Functions i) + Cardinal.lift.{u, u'} #(L'.Functions i)
-- FirstOrder.Language.card_relations_sum
@[simp]
theorem card_relations_sum (i : ℕ) :
    #((L.sum L').Relations i) =
      Cardinal.lift.{v'} #(L.Relations i) + Cardinal.lift.{v} #(L'.Relations i) 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language} (i : ℕ)
Goal: #((L.sum L').Relations i) = Cardinal.lift.{v', v} #(L.Relations i) + Cardinal.lift.{v, v'} #(L'.Relations i)
-- FirstOrder.Language.card_sum
@[simp]
theorem card_sum :
    (L.sum L').card = Cardinal.lift.{max u' v'} L.card + Cardinal.lift.{max u v} L'.card 
Arguments: {L : FirstOrder.Language} {L' : FirstOrder.Language}
Goal: (L.sum L').card = Cardinal.lift.{max u' v', max u v} L.card + Cardinal.lift.{max u v, max u' v'} L'.card
-- FirstOrder.Language.card_mk₂
@[simp]
theorem card_mk₂ (c f₁ f₂ : Type u) (r₁ r₂ : Type v) :
    (Language.mk₂ c f₁ f₂ r₁ r₂).card =
      Cardinal.lift.{v} #c + Cardinal.lift.{v} #f₁ + Cardinal.lift.{v} #f₂ +
          Cardinal.lift.{u} #r₁ + Cardinal.lift.{u} #r₂ 
Arguments: (c f₁ f₂ : Type u) (r₁ r₂ : Type v)
Goal: (FirstOrder.Language.mk₂ c f₁ f₂ r₁ r₂).card =
  Cardinal.lift.{v, u} #c + Cardinal.lift.{v, u} #f₁ + Cardinal.lift.{v, u} #f₂ + Cardinal.lift.{u, v} #r₁ +
    Cardinal.lift.{u, v} #r₂
-- FirstOrder.Language.Hom.map_fun'
structure Hom where
    toFun : M → N
    -- Porting note:
  -- The autoparam here used to be `obviously`. We would like to replace it with `aesop`
  -- but that isn't currently sufficient.
  -- See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Aesop.20and.20cases
  -- If that can be improved, we should change this to `by aesop` and remove the proofs below.
  map_fun' : ∀ {n} (f : L.Functions n) (x), toFun (funMap f x) = funMap f (toFun ∘ x) := by
    intros; trivial
    map_rel' : ∀ {n} (r : L.Relations n) (x), RelMap r x → RelMap r (toFun ∘ x) := by
    -- Porting note: see porting note on `Hom.map_fun'`
    intros; trivial
Arguments: {L : FirstOrder.Language} {M : Type w} {N : Type w'} [L.Structure M] [L.Structure N] (self : L.Hom M N) {n : ℕ} (f : L.Functions n) (x : Fin n → M)
Goal: self.toFun (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (self.toFun ∘ x)