File: Mathlib/RingTheory/Norm/Basic.lean

full_name: Algebra.PowerBasis.norm_gen_eq_coeff_zero_minpoly
code: /-- Given `pb : PowerBasis K S`, then the norm of `pb.gen` is
`(-1) ^ pb.dim * coeff (minpoly K pb.gen) 0`. -/
theorem PowerBasis.norm_gen_eq_coeff_zero_minpoly (pb : PowerBasis R S) :
    norm R pb.gen = (-1) ^ pb.dim * coeff (minpoly R pb.gen) 0 
goal: (Algebra.norm R) pb.gen = (-1) ^ pb.dim * (minpoly R pb.gen).coeff 0

full_name: Algebra.PowerBasis.norm_gen_eq_prod_roots
code: /-- Given `pb : PowerBasis R S`, then the norm of `pb.gen` is
`((minpoly R pb.gen).aroots F).prod`. -/
theorem PowerBasis.norm_gen_eq_prod_roots [Algebra R F] (pb : PowerBasis R S)
    (hf : (minpoly R pb.gen).Splits (algebraMap R F)) :
    algebraMap R F (norm R pb.gen) = ((minpoly R pb.gen).aroots F).prod 
goal: (algebraMap R F) ((Algebra.norm R) pb.gen) = ((minpoly R pb.gen).aroots F).prod

full_name: Algebra.norm_zero
code: @[simp]
theorem norm_zero [Nontrivial S] [Module.Free R S] [Module.Finite R S] : norm R (0 : S) = 0 
goal: (Algebra.norm R) 0 = 0

full_name: Algebra.norm_eq_zero_iff
code: @[simp]
theorem norm_eq_zero_iff [IsDomain R] [IsDomain S] [Module.Free R S] [Module.Finite R S] {x : S} :
    norm R x = 0 ↔ x = 0 
goal: (Algebra.norm R) x = 0 ↔ x = 0

full_name: Algebra.norm_ne_zero_iff
code: theorem norm_ne_zero_iff [IsDomain R] [IsDomain S] [Module.Free R S] [Module.Finite R S] {x : S} :
    norm R x ≠ 0 ↔ x ≠ 0 
goal: (Algebra.norm R) x ≠ 0 ↔ x ≠ 0

full_name: Algebra.norm_eq_zero_iff'
code: /-- This is `Algebra.norm_eq_zero_iff` composed with `Algebra.norm_apply`. -/
@[simp]
theorem norm_eq_zero_iff' [IsDomain R] [IsDomain S] [Module.Free R S] [Module.Finite R S] {x : S} :
    LinearMap.det (LinearMap.mul R S x) = 0 ↔ x = 0 
goal: LinearMap.det ((LinearMap.mul R S) x) = 0 ↔ x = 0

full_name: Algebra.norm_eq_zero_iff_of_basis
code: theorem norm_eq_zero_iff_of_basis [IsDomain R] [IsDomain S] (b : Basis ι R S) {x : S} :
    Algebra.norm R x = 0 ↔ x = 0 
goal: (Algebra.norm R) x = 0 ↔ x = 0

full_name: Algebra.norm_ne_zero_iff_of_basis
code: theorem norm_ne_zero_iff_of_basis [IsDomain R] [IsDomain S] (b : Basis ι R S) {x : S} :
    Algebra.norm R x ≠ 0 ↔ x ≠ 0 
goal: (Algebra.norm R) x ≠ 0 ↔ x ≠ 0

full_name: Algebra.norm_eq_norm_adjoin
code: theorem norm_eq_norm_adjoin [FiniteDimensional K L] [Algebra.IsSeparable K L] (x : L) :
    norm K x = norm K (AdjoinSimple.gen K x) ^ finrank K⟮x⟯ L 
goal: (Algebra.norm K) x = (Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x) ^ FiniteDimensional.finrank (↥K⟮x⟯) L

full_name: IntermediateField.AdjoinSimple.norm_gen_eq_one
code: theorem _root_.IntermediateField.AdjoinSimple.norm_gen_eq_one {x : L} (hx : ¬IsIntegral K x) :
    norm K (AdjoinSimple.gen K x) = 1 
goal: (Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x) = 1

full_name: IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots
code: theorem _root_.IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots (x : L)
    (hf : (minpoly K x).Splits (algebraMap K F)) :
    (algebraMap K F) (norm K (AdjoinSimple.gen K x)) =
      ((minpoly K x).aroots F).prod 
goal: (algebraMap K F) ((Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x)) = ((minpoly K x).aroots F).prod

full_name: Algebra.norm_eq_prod_embeddings_gen
code: theorem norm_eq_prod_embeddings_gen [Algebra R F] (pb : PowerBasis R S)
    (hE : (minpoly R pb.gen).Splits (algebraMap R F)) (hfx : IsSeparable R pb.gen) :
    algebraMap R F (norm R pb.gen) =
      (@Finset.univ _ (PowerBasis.AlgHom.fintype pb)).prod fun σ => σ pb.gen 
goal: (algebraMap R F) ((Algebra.norm R) pb.gen) = ∏ σ : S →ₐ[R] F, σ pb.gen

full_name: Algebra.norm_eq_prod_roots
code: theorem norm_eq_prod_roots [Algebra.IsSeparable K L] [FiniteDimensional K L] {x : L}
    (hF : (minpoly K x).Splits (algebraMap K F)) :
    algebraMap K F (norm K x) =
      ((minpoly K x).aroots F).prod ^ finrank K⟮x⟯ L 
goal: (algebraMap K F) ((Algebra.norm K) x) = ((minpoly K x).aroots F).prod ^ FiniteDimensional.finrank (↥K⟮x⟯) L

full_name: Algebra.prod_embeddings_eq_finrank_pow
code: theorem prod_embeddings_eq_finrank_pow [Algebra L F] [IsScalarTower K L F] [IsAlgClosed E]
    [Algebra.IsSeparable K F] [FiniteDimensional K F] (pb : PowerBasis K L) :
    ∏ σ : F →ₐ[K] E, σ (algebraMap L F pb.gen) =
      ((@Finset.univ _ (PowerBasis.AlgHom.fintype pb)).prod
        fun σ : L →ₐ[K] E => σ pb.gen) ^ finrank L F 
goal: ∏ σ : F →ₐ[K] E, σ ((algebraMap L F) pb.gen) = (∏ σ : L →ₐ[K] E, σ pb.gen) ^ FiniteDimensional.finrank L F

full_name: Algebra.norm_eq_prod_embeddings
code: /-- For `L/K` a finite separable extension of fields and `E` an algebraically closed extension
of `K`, the norm (down to `K`) of an element `x` of `L` is equal to the product of the images
of `x` over all the `K`-embeddings `σ` of `L` into `E`. -/
theorem norm_eq_prod_embeddings [FiniteDimensional K L] [Algebra.IsSeparable K L] [IsAlgClosed E]
    (x : L) : algebraMap K E (norm K x) = ∏ σ : L →ₐ[K] E, σ x 
goal: (algebraMap K E) ((Algebra.norm K) x) = ∏ σ : L →ₐ[K] E, σ x

full_name: Algebra.norm_eq_prod_automorphisms
code: theorem norm_eq_prod_automorphisms [FiniteDimensional K L] [IsGalois K L] (x : L) :
    algebraMap K L (norm K x) = ∏ σ : L ≃ₐ[K] L, σ x 
goal: (algebraMap K L) ((Algebra.norm K) x) = ∏ σ : L ≃ₐ[K] L, σ x

full_name: Algebra.isIntegral_norm
code: theorem isIntegral_norm [Algebra R L] [Algebra R K] [IsScalarTower R K L] [Algebra.IsSeparable K L]
    [FiniteDimensional K L] {x : L} (hx : IsIntegral R x) : IsIntegral R (norm K x) 
goal: IsIntegral R ((Algebra.norm K) x)

full_name: Algebra.norm_eq_of_algEquiv
code: lemma norm_eq_of_algEquiv [Ring T] [Algebra R T] (e : S ≃ₐ[R] T) (x) :
    Algebra.norm R (e x) = Algebra.norm R x 
goal: (Algebra.norm R) (e x) = (Algebra.norm R) x

full_name: Algebra.norm_eq_of_ringEquiv
code: lemma norm_eq_of_ringEquiv {A B C : Type*} [CommRing A] [CommRing B] [Ring C]
    [Algebra A C] [Algebra B C] (e : A ≃+* B) (he : (algebraMap B C).comp e = algebraMap A C)
    (x : C) :
    e (Algebra.norm A x) = Algebra.norm B x 
goal: e ((Algebra.norm A) x) = (Algebra.norm B) x

full_name: Algebra.norm_eq_of_equiv_equiv
code: lemma norm_eq_of_equiv_equiv {A₁ B₁ A₂ B₂ : Type*} [CommRing A₁] [Ring B₁]
    [CommRing A₂] [Ring B₂] [Algebra A₁ B₁] [Algebra A₂ B₂] (e₁ : A₁ ≃+* A₂) (e₂ : B₁ ≃+* B₂)
    (he : RingHom.comp (algebraMap A₂ B₂) ↑e₁ = RingHom.comp ↑e₂ (algebraMap A₁ B₁)) (x) :
    Algebra.norm A₁ x = e₁.symm (Algebra.norm A₂ (e₂ x)) 
goal: (Algebra.norm A₁) x = e₁.symm ((Algebra.norm A₂) (e₂ x))

full_name: Algebra.norm_norm
code: theorem norm_norm [Algebra L F] [IsScalarTower K L F] [Algebra.IsSeparable K F] (x : F) :
    norm K (norm L x) = norm K x 
goal: (Algebra.norm K) ((Algebra.norm L) x) = (Algebra.norm K) x