File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

full_name: isCyclotomicExtension_iff
code: /-- Given an `A`-algebra `B` and `S : Set ℕ+`, we define `IsCyclotomicExtension S A B` requiring
that there is an `n`-th primitive root of unity in `B` for all `n ∈ S` and that `B` is generated
over `A` by the roots of `X ^ n - 1`. -/

@[mk_iff]
class IsCyclotomicExtension : Prop where
  /-- For all `n ∈ S`, there exists a primitive `n`-th root of unity in `B`. -/
  exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
  /-- The `n`-th roots of unity, for `n ∈ S`, generate `B` as an `A`-algebra. -/
  adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
goal: IsCyclotomicExtension S A B ↔
  (∀ {n : ℕ+}, n ∈ S → ∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1}

full_name: IsCyclotomicExtension.exists_prim_root
code: /-- Given an `A`-algebra `B` and `S : Set ℕ+`, we define `IsCyclotomicExtension S A B` requiring
that there is an `n`-th primitive root of unity in `B` for all `n ∈ S` and that `B` is generated
over `A` by the roots of `X ^ n - 1`. -/

@[mk_iff]
class IsCyclotomicExtension : Prop where
  /-- For all `n ∈ S`, there exists a primitive `n`-th root of unity in `B`. -/
  exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
  /-- The `n`-th roots of unity, for `n ∈ S`, generate `B` as an `A`-algebra. -/
  adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
goal: ∃ r, IsPrimitiveRoot r ↑n

full_name: IsCyclotomicExtension.adjoin_roots
code: /-- Given an `A`-algebra `B` and `S : Set ℕ+`, we define `IsCyclotomicExtension S A B` requiring
that there is an `n`-th primitive root of unity in `B` for all `n ∈ S` and that `B` is generated
over `A` by the roots of `X ^ n - 1`. -/

@[mk_iff]
class IsCyclotomicExtension : Prop where
  /-- For all `n ∈ S`, there exists a primitive `n`-th root of unity in `B`. -/
  exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
  /-- The `n`-th roots of unity, for `n ∈ S`, generate `B` as an `A`-algebra. -/
  adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
goal: x ∈ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1}

full_name: IsCyclotomicExtension
code: /-- Given an `A`-algebra `B` and `S : Set ℕ+`, we define `IsCyclotomicExtension S A B` requiring
that there is an `n`-th primitive root of unity in `B` for all `n ∈ S` and that `B` is generated
over `A` by the roots of `X ^ n - 1`. -/

@[mk_iff]
class IsCyclotomicExtension : Prop where
  /-- For all `n ∈ S`, there exists a primitive `n`-th root of unity in `B`. -/
  exists_prim_root {n : ℕ+} (ha : n ∈ S) : ∃ r : B, IsPrimitiveRoot r n
  /-- The `n`-th roots of unity, for `n ∈ S`, generate `B` as an `A`-algebra. -/
  adjoin_roots : ∀ x : B, x ∈ adjoin A {b : B | ∃ n : ℕ+, n ∈ S ∧ b ^ (n : ℕ) = 1}
goal: Prop

full_name: IsCyclotomicExtension.iff_adjoin_eq_top
code: /-- A reformulation of `IsCyclotomicExtension` that uses `⊤`. -/
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} = ⊤ 
goal: IsCyclotomicExtension S A B ↔ (∀ n ∈ S, ∃ r, IsPrimitiveRoot r ↑n) ∧ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1} = ⊤

full_name: IsCyclotomicExtension.iff_singleton
code: /-- A reformulation of `IsCyclotomicExtension` in the case `S` is a singleton. -/
theorem iff_singleton :
    IsCyclotomicExtension {n} A B ↔
      (∃ r : B, IsPrimitiveRoot r n) ∧ ∀ x, x ∈ adjoin A {b : B | b ^ (n : ℕ) = 1} 
goal: IsCyclotomicExtension {n} A B ↔ (∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ Algebra.adjoin A {b | b ^ ↑n = 1}

full_name: IsCyclotomicExtension.empty
code: /-- If `IsCyclotomicExtension ∅ A B`, then the image of `A` in `B` equals `B`. -/
theorem empty [h : IsCyclotomicExtension ∅ A B] : (⊥ : Subalgebra A B) = ⊤ 
goal: ⊥ = ⊤

full_name: IsCyclotomicExtension.singleton_one
code: /-- If `IsCyclotomicExtension {1} A B`, then the image of `A` in `B` equals `B`. -/
theorem singleton_one [h : IsCyclotomicExtension {1} A B] : (⊥ : Subalgebra A B) = ⊤ 
goal: ⊥ = ⊤

full_name: IsCyclotomicExtension.singleton_zero_of_bot_eq_top
code: /-- If `(⊥ : SubAlgebra A B) = ⊤`, then `IsCyclotomicExtension ∅ A B`. -/
theorem singleton_zero_of_bot_eq_top (h : (⊥ : Subalgebra A B) = ⊤) :
    IsCyclotomicExtension ∅ A B 
goal: IsCyclotomicExtension ∅ A B

full_name: IsCyclotomicExtension.trans
code: /-- Transitivity of cyclotomic extensions. -/
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 
goal: IsCyclotomicExtension (S ∪ T) A C

full_name: IsCyclotomicExtension.subsingleton_iff
code: @[nontriviality]
theorem subsingleton_iff [Subsingleton B] : IsCyclotomicExtension S A B ↔ S = { } ∨ S = {1} 
goal: IsCyclotomicExtension S A B ↔ S = ∅ ∨ S = {1}

full_name: IsCyclotomicExtension.union_right
code: /-- If `B` is a cyclotomic extension of `A` given by roots of unity of order in `S ∪ T`, then `B`
is a cyclotomic extension of `adjoin A { b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1 }` given by
roots of unity of order in `T`. -/
theorem union_right [h : IsCyclotomicExtension (S ∪ T) A B] :
    IsCyclotomicExtension T (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1}) B 
goal: IsCyclotomicExtension T (↥(Algebra.adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1})) B

full_name: IsCyclotomicExtension.union_left
code: /-- If `B` is a cyclotomic extension of `A` given by roots of unity of order in `T` and `S ⊆ T`,
then `adjoin A { b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1 }` is a cyclotomic extension of `B`
given by roots of unity of order in `S`. -/
theorem union_left [h : IsCyclotomicExtension T A B] (hS : S ⊆ T) :
    IsCyclotomicExtension S A (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1}) 
goal: IsCyclotomicExtension S A ↥(Algebra.adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1})

full_name: IsCyclotomicExtension.of_union_of_dvd
code: /-- If `∀ s ∈ S, n ∣ s` and `S` is not empty, then `IsCyclotomicExtension S A B` implies
`IsCyclotomicExtension (S ∪ {n}) A B`. -/
theorem of_union_of_dvd (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty) [H : IsCyclotomicExtension S A B] :
    IsCyclotomicExtension (S ∪ {n}) A B 
goal: IsCyclotomicExtension (S ∪ {n}) A B

full_name: IsCyclotomicExtension.iff_union_of_dvd
code: /-- If `∀ s ∈ S, n ∣ s` and `S` is not empty, then `IsCyclotomicExtension S A B` if and only if
`IsCyclotomicExtension (S ∪ {n}) A B`. -/
theorem iff_union_of_dvd (h : ∀ s ∈ S, n ∣ s) (hS : S.Nonempty) :
    IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {n}) A B 
goal: IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {n}) A B

full_name: IsCyclotomicExtension.iff_union_singleton_one
code: /-- `IsCyclotomicExtension S A B` is equivalent to `IsCyclotomicExtension (S ∪ {1}) A B`. -/
theorem iff_union_singleton_one :
    IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {1}) A B 
goal: IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {1}) A B

full_name: IsCyclotomicExtension.singleton_one_of_bot_eq_top
code: /-- If `(⊥ : SubAlgebra A B) = ⊤`, then `IsCyclotomicExtension {1} A B`. -/
theorem singleton_one_of_bot_eq_top (h : (⊥ : Subalgebra A B) = ⊤) :
    IsCyclotomicExtension {1} A B 
goal: IsCyclotomicExtension {1} A B

full_name: IsCyclotomicExtension.singleton_one_of_algebraMap_bijective
code: /-- If `Function.Surjective (algebraMap A B)`, then `IsCyclotomicExtension {1} A B`. -/
theorem singleton_one_of_algebraMap_bijective (h : Function.Surjective (algebraMap A B)) :
    IsCyclotomicExtension {1} A B 
goal: IsCyclotomicExtension {1} A B

full_name: IsCyclotomicExtension.equiv
code: /-- Given `(f : B ≃ₐ[A] C)`, if `IsCyclotomicExtension S A B` then
`IsCyclotomicExtension S A C`. -/
protected
theorem equiv {C : Type*} [CommRing C] [Algebra A C] [h : IsCyclotomicExtension S A B]
    (f : B ≃ₐ[A] C) : IsCyclotomicExtension S A C 
goal: IsCyclotomicExtension S A C

full_name: IsCyclotomicExtension.neZero
code: protected
theorem neZero [h : IsCyclotomicExtension {n} A B] [IsDomain B] : NeZero ((n : ℕ) : B) 
goal: NeZero ↑↑n

full_name: IsCyclotomicExtension.neZero'
code: protected
theorem neZero' [IsCyclotomicExtension {n} A B] [IsDomain B] : NeZero ((n : ℕ) : A) 
goal: NeZero ↑↑n

full_name: IsCyclotomicExtension.finite_of_singleton
code: theorem finite_of_singleton [IsDomain B] [h : IsCyclotomicExtension {n} A B] :
    Module.Finite A B 
goal: Module.Finite A B

full_name: IsCyclotomicExtension.finite
code: /-- If `S` is finite and `IsCyclotomicExtension S A B`, then `B` is a finite `A`-algebra. -/
protected theorem finite [IsDomain B] [h₁ : Finite S] [h₂ : IsCyclotomicExtension S A B] :
    Module.Finite A B 
goal: Module.Finite A B

full_name: IsCyclotomicExtension.numberField
code: /-- A cyclotomic finite extension of a number field is a number field. -/
theorem numberField [h : NumberField K] [Finite S] [IsCyclotomicExtension S K L] : NumberField L 
goal: NumberField L

full_name: IsCyclotomicExtension.integral
code: /-- A finite cyclotomic extension of an integral noetherian domain is integral -/
theorem integral [IsDomain B] [IsNoetherianRing A] [Finite S] [IsCyclotomicExtension S A B] :
    Algebra.IsIntegral A B 
goal: Algebra.IsIntegral A B

full_name: IsCyclotomicExtension.finiteDimensional
code: /-- If `S` is finite and `IsCyclotomicExtension S K A`, then `finiteDimensional K A`. -/
theorem finiteDimensional (C : Type z) [Finite S] [CommRing C] [Algebra K C] [IsDomain C]
    [IsCyclotomicExtension S K C] : FiniteDimensional K C 
goal: FiniteDimensional K C

full_name: IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots
code: 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} 
goal: Algebra.adjoin A ((Polynomial.cyclotomic (↑n) A).rootSet B) = Algebra.adjoin A {b | ∃ a ∈ {n}, b ^ ↑a = 1}

full_name: IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic
code: theorem adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic {n : ℕ+} [IsDomain B] {ζ : B}
    (hζ : IsPrimitiveRoot ζ n) : adjoin A ((cyclotomic n A).rootSet B) = adjoin A {ζ} 
goal: Algebra.adjoin A ((Polynomial.cyclotomic (↑n) A).rootSet B) = Algebra.adjoin A {ζ}

full_name: IsCyclotomicExtension.adjoin_primitive_root_eq_top
code: theorem adjoin_primitive_root_eq_top {n : ℕ+} [IsDomain B] [h : IsCyclotomicExtension {n} A B]
    {ζ : B} (hζ : IsPrimitiveRoot ζ n) : adjoin A ({ζ} : Set B) = ⊤ 
goal: Algebra.adjoin A {ζ} = ⊤

full_name: IsPrimitiveRoot.adjoin_isCyclotomicExtension
code: theorem _root_.IsPrimitiveRoot.adjoin_isCyclotomicExtension {ζ : B} {n : ℕ+}
    (h : IsPrimitiveRoot ζ n) : IsCyclotomicExtension {n} A (adjoin A ({ζ} : Set B)) 
goal: IsCyclotomicExtension {n} A ↥(Algebra.adjoin A {ζ})

full_name: IsCyclotomicExtension.splits_X_pow_sub_one
code: /-- A cyclotomic extension splits `X ^ n - 1` if `n ∈ S`. -/
theorem splits_X_pow_sub_one [H : IsCyclotomicExtension S K L] (hS : n ∈ S) :
    Splits (algebraMap K L) (X ^ (n : ℕ) - 1) 
goal: Polynomial.Splits (algebraMap K L) (Polynomial.X ^ ↑n - 1)

full_name: IsCyclotomicExtension.splits_cyclotomic
code: /-- A cyclotomic extension splits `cyclotomic n K` if `n ∈ S` and `ne_zero (n : K)`. -/
theorem splits_cyclotomic [IsCyclotomicExtension S K L] (hS : n ∈ S) :
    Splits (algebraMap K L) (cyclotomic n K) 
goal: Polynomial.Splits (algebraMap K L) (Polynomial.cyclotomic (↑n) K)

full_name: IsCyclotomicExtension.isSplittingField_X_pow_sub_one
code: /-- If `IsCyclotomicExtension {n} K L`, then `L` is the splitting field of `X ^ n - 1`. -/
theorem isSplittingField_X_pow_sub_one : IsSplittingField K L (X ^ (n : ℕ) - 1) 
goal: Polynomial.IsSplittingField K L (Polynomial.X ^ ↑n - 1)

full_name: IsCyclotomicExtension.algEquiv
code: /-- Any two `n`-th cyclotomic extensions are isomorphic. -/
def algEquiv (L' : Type*) [Field L'] [Algebra K L'] [IsCyclotomicExtension {n} K L'] :
    L ≃ₐ[K] L' 
goal: L ≃ₐ[K] L'

full_name: IsCyclotomicExtension.isGalois
code: theorem isGalois : IsGalois K L 
goal: IsGalois K L

full_name: IsCyclotomicExtension.splitting_field_cyclotomic
code: /-- If `IsCyclotomicExtension {n} K L`, then `L` is the splitting field of `cyclotomic n K`. -/
theorem splitting_field_cyclotomic : IsSplittingField K L (cyclotomic n K) 
goal: Polynomial.IsSplittingField K L (Polynomial.cyclotomic (↑n) K)

full_name: CyclotomicField
code: /-- Given `n : ℕ+` and a field `K`, we define `CyclotomicField n K` as the
splitting field of `cyclotomic n K`. If `n` is nonzero in `K`, it has
the instance `IsCyclotomicExtension {n} K (CyclotomicField n K)`. -/
def CyclotomicField : Type w 
goal: Type w

full_name: CyclotomicField.instField
code: instance : Field (CyclotomicField n K) 
goal: Field (CyclotomicField n K)

full_name: CyclotomicField.algebra
code: instance algebra : Algebra K (CyclotomicField n K) 
goal: Algebra K (CyclotomicField n K)

full_name: CyclotomicField.instInhabited
code: instance : Inhabited (CyclotomicField n K) 
goal: Inhabited (CyclotomicField n K)

full_name: CyclotomicField.instCharZero
code: instance [CharZero K] : CharZero (CyclotomicField n K) 
goal: CharZero (CyclotomicField n K)

full_name: CyclotomicField.isCyclotomicExtension
code: instance isCyclotomicExtension [NeZero ((n : ℕ) : K)] :
    IsCyclotomicExtension {n} K (CyclotomicField n K) 
goal: IsCyclotomicExtension {n} K (CyclotomicField n K)

full_name: CyclotomicField.algebraBase
code: /-- If `K` is the fraction field of `A`, the `A`-algebra structure on `CyclotomicField n K`.
-/
@[nolint unusedArguments]
instance CyclotomicField.algebraBase : Algebra A (CyclotomicField n K) 
goal: Algebra A (CyclotomicField n K)

full_name: CyclotomicField.algebra'
code: instance CyclotomicField.algebra' {R : Type*} [CommRing R] [Algebra R K] :
    Algebra R (CyclotomicField n K) 
goal: Algebra R (CyclotomicField n K)

full_name: instIsScalarTowerCyclotomicField
code: instance {R : Type*} [CommRing R] [Algebra R K] : IsScalarTower R K (CyclotomicField n K) 
goal: IsScalarTower R K (CyclotomicField n K)

full_name: CyclotomicField.noZeroSMulDivisors
code: instance CyclotomicField.noZeroSMulDivisors : NoZeroSMulDivisors A (CyclotomicField n K) 
goal: NoZeroSMulDivisors A (CyclotomicField n K)

full_name: CyclotomicRing
code: /-- If `A` is a domain with fraction field `K` and `n : ℕ+`, we define `CyclotomicRing n A K` as
the `A`-subalgebra of `CyclotomicField n K` generated by the roots of `X ^ n - 1`. If `n`
is nonzero in `A`, it has the instance `IsCyclotomicExtension {n} A (CyclotomicRing n A K)`. -/
@[nolint unusedArguments]
def CyclotomicRing : Type w 
goal: Type w

full_name: CyclotomicRing.instCommRing
code: instance : CommRing (CyclotomicRing n A K) 
goal: CommRing (CyclotomicRing n A K)

full_name: CyclotomicRing.instIsDomain
code: instance : IsDomain (CyclotomicRing n A K) 
goal: IsDomain (CyclotomicRing n A K)

full_name: CyclotomicRing.instInhabited
code: instance : Inhabited (CyclotomicRing n A K) 
goal: Inhabited (CyclotomicRing n A K)

full_name: CyclotomicRing.algebraBase
code: /-- The `A`-algebra structure on `CyclotomicRing n A K`. -/
instance algebraBase : Algebra A (CyclotomicRing n A K) 
goal: Algebra A (CyclotomicRing n A K)

full_name: CyclotomicRing.instNoZeroSMulDivisors
code: instance : NoZeroSMulDivisors A (CyclotomicRing n A K) 
goal: NoZeroSMulDivisors A (CyclotomicRing n A K)

full_name: CyclotomicRing.algebraBase_injective
code: theorem algebraBase_injective : Function.Injective <| algebraMap A (CyclotomicRing n A K) 
goal: Function.Injective ⇑(algebraMap A (CyclotomicRing n A K))

full_name: CyclotomicRing.instAlgebraCyclotomicField
code: instance : Algebra (CyclotomicRing n A K) (CyclotomicField n K) 
goal: Algebra (CyclotomicRing n A K) (CyclotomicField n K)

full_name: CyclotomicRing.adjoin_algebra_injective
code: theorem adjoin_algebra_injective :
    Function.Injective <| algebraMap (CyclotomicRing n A K) (CyclotomicField n K) 
goal: Function.Injective ⇑(algebraMap (CyclotomicRing n A K) (CyclotomicField n K))

full_name: CyclotomicRing.instNoZeroSMulDivisorsCyclotomicField
code: instance : NoZeroSMulDivisors (CyclotomicRing n A K) (CyclotomicField n K) 
goal: NoZeroSMulDivisors (CyclotomicRing n A K) (CyclotomicField n K)

full_name: CyclotomicRing.instIsScalarTowerCyclotomicField
code: instance : IsScalarTower A (CyclotomicRing n A K) (CyclotomicField n K) 
goal: IsScalarTower A (CyclotomicRing n A K) (CyclotomicField n K)

full_name: CyclotomicRing.isCyclotomicExtension
code: instance isCyclotomicExtension [NeZero ((n : ℕ) : A)] :
    IsCyclotomicExtension {n} A (CyclotomicRing n A K) 
goal: IsCyclotomicExtension {n} A (CyclotomicRing n A K)

full_name: CyclotomicRing.instIsFractionRingCyclotomicFieldOfIsDomainOfNeZeroCastVal
code: instance [IsDomain A] [NeZero ((n : ℕ) : A)] :
    IsFractionRing (CyclotomicRing n A K) (CyclotomicField n K) 
goal: IsFractionRing (CyclotomicRing n A K) (CyclotomicField n K)

full_name: CyclotomicRing.eq_adjoin_primitive_root
code: theorem eq_adjoin_primitive_root {μ : CyclotomicField n K} (h : IsPrimitiveRoot μ n) :
    CyclotomicRing n A K = adjoin A ({μ} : Set (CyclotomicField n K)) 
goal: CyclotomicRing n A K = ↥(Algebra.adjoin A {μ})

full_name: IsAlgClosed.isCyclotomicExtension
code: /-- Algebraically closed fields are `S`-cyclotomic extensions over themselves if
`NeZero ((a : ℕ) : K))` for all `a ∈ S`. -/
theorem IsAlgClosed.isCyclotomicExtension (h : ∀ a ∈ S, NeZero ((a : ℕ) : K)) :
    IsCyclotomicExtension S K K 
goal: IsCyclotomicExtension S K K

full_name: IsAlgClosedOfCharZero.isCyclotomicExtension
code: instance IsAlgClosedOfCharZero.isCyclotomicExtension [CharZero K] :
    ∀ S, IsCyclotomicExtension S K K 
goal: IsCyclotomicExtension S K K