File: Mathlib/NumberTheory/KummerDedekind.lean

full_name: «_aux_Mathlib_NumberTheory_KummerDedekind___macroRules_term_<_>_1»
code: local notation:max R "<" x:max ">" => adjoin R ({x} : Set S)
goal: Lean.Macro

full_name: _aux_Mathlib_NumberTheory_KummerDedekind___unexpand_Algebra_adjoin_1
code: local notation:max R "<" x:max ">" => adjoin R ({x} : Set S)
goal: Lean.PrettyPrinter.Unexpander

full_name: conductor
code: /-- Let `S / R` be a ring extension and `x : S`, then the conductor of `R<x>` is the
    biggest ideal of `S` contained in `R<x>`. -/
def conductor (x : S) : Ideal S 
goal: Ideal S

full_name: conductor_eq_of_eq
code: theorem conductor_eq_of_eq {y : S} (h : (R<x> : Set S) = R<y>) : conductor R x = conductor R y 
goal: conductor R x = conductor R y

full_name: conductor_subset_adjoin
code: theorem conductor_subset_adjoin : (conductor R x : Set S) ⊆ R<x> 
goal: ↑(conductor R x) ⊆ ↑(Algebra.adjoin R {x})

full_name: mem_conductor_iff
code: theorem mem_conductor_iff {y : S} : y ∈ conductor R x ↔ ∀ b : S, y * b ∈ R<x> 
goal: y ∈ conductor R x ↔ ∀ (b : S), y * b ∈ Algebra.adjoin R {x}

full_name: conductor_eq_top_of_adjoin_eq_top
code: theorem conductor_eq_top_of_adjoin_eq_top (h : R<x> = ⊤) : conductor R x = ⊤ 
goal: conductor R x = ⊤

full_name: conductor_eq_top_of_powerBasis
code: theorem conductor_eq_top_of_powerBasis (pb : PowerBasis R S) : conductor R pb.gen = ⊤ 
goal: conductor R pb.gen = ⊤

full_name: mem_coeSubmodule_conductor
code: lemma mem_coeSubmodule_conductor {L} [CommRing L] [Algebra S L] [Algebra R L]
    [IsScalarTower R S L] [NoZeroSMulDivisors S L] {x : S} {y : L} :
    y ∈ coeSubmodule L (conductor R x) ↔ ∀ z : S,
      y * (algebraMap S L) z ∈ Algebra.adjoin R {algebraMap S L x} 
goal: y ∈ IsLocalization.coeSubmodule L (conductor R x) ↔
  ∀ (z : S), y * (algebraMap S L) z ∈ Algebra.adjoin R {(algebraMap S L) x}

full_name: prod_mem_ideal_map_of_mem_conductor
code: /-- This technical lemma tell us that if `C` is the conductor of `R<x>` and `I` is an ideal of `R`
  then `p * (I * S) ⊆ I * R<x>` for any `p` in `C ∩ R` -/
theorem prod_mem_ideal_map_of_mem_conductor {p : R} {z : S}
    (hp : p ∈ Ideal.comap (algebraMap R S) (conductor R x)) (hz' : z ∈ I.map (algebraMap R S)) :
    algebraMap R S p * z ∈ algebraMap R<x> S '' ↑(I.map (algebraMap R R<x>)) 
goal: (algebraMap R S) p * z ∈
  ⇑(algebraMap (↥(Algebra.adjoin R {x})) S) '' ↑(Ideal.map (algebraMap R ↥(Algebra.adjoin R {x})) I)

full_name: comap_map_eq_map_adjoin_of_coprime_conductor
code: /-- A technical result telling us that `(I * S) ∩ R<x> = I * R<x>` for any ideal `I` of `R`. -/
theorem comap_map_eq_map_adjoin_of_coprime_conductor
    (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤)
    (h_alg : Function.Injective (algebraMap R<x> S)) :
    (I.map (algebraMap R S)).comap (algebraMap R<x> S) = I.map (algebraMap R R<x>) 
goal: Ideal.comap (algebraMap (↥(Algebra.adjoin R {x})) S) (Ideal.map (algebraMap R S) I) =
  Ideal.map (algebraMap R ↥(Algebra.adjoin R {x})) I

full_name: quotAdjoinEquivQuotMap
code: /-- The canonical morphism of rings from `R<x> ⧸ (I*R<x>)` to `S ⧸ (I*S)` is an isomorphism
    when `I` and `(conductor R x) ∩ R` are coprime. -/
noncomputable def quotAdjoinEquivQuotMap (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤)
    (h_alg : Function.Injective (algebraMap R<x> S)) :
    R<x> ⧸ I.map (algebraMap R R<x>) ≃+* S ⧸ I.map (algebraMap R S) 
goal: ↥(Algebra.adjoin R {x}) ⧸ Ideal.map (algebraMap R ↥(Algebra.adjoin R {x})) I ≃+* S ⧸ Ideal.map (algebraMap R S) I

full_name: quotAdjoinEquivQuotMap_apply_mk
code: @[simp]
theorem quotAdjoinEquivQuotMap_apply_mk (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤)
    (h_alg : Function.Injective (algebraMap R<x> S)) (a : R<x>) :
    quotAdjoinEquivQuotMap hx h_alg (Ideal.Quotient.mk (I.map (algebraMap R R<x>)) a) =
      Ideal.Quotient.mk (I.map (algebraMap R S)) ↑a 
goal: (quotAdjoinEquivQuotMap hx h_alg) ((Ideal.Quotient.mk (Ideal.map (algebraMap R ↥(Algebra.adjoin R {x})) I)) a) =
  (Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ↑a

full_name: KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk
code: /-- The first half of the **Kummer-Dedekind Theorem** in the monogenic case, stating that the prime
    factors of `I*S` are in bijection with those of the minimal polynomial of the generator of `S`
    over `R`, taken `mod I`. -/
noncomputable def normalizedFactorsMapEquivNormalizedFactorsMinPolyMk (hI : IsMaximal I)
    (hI' : I ≠ ⊥) (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤) (hx' : IsIntegral R x) :
    {J : Ideal S | J ∈ normalizedFactors (I.map (algebraMap R S))} ≃
      {d : (R ⧸ I)[X] |
        d ∈ normalizedFactors (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))} 
goal: ↑{J | J ∈ UniqueFactorizationMonoid.normalizedFactors (Ideal.map (algebraMap R S) I)} ≃
  ↑{d | d ∈ UniqueFactorizationMonoid.normalizedFactors (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))}

full_name: KummerDedekind.multiplicity_factors_map_eq_multiplicity
code: /-- The second half of the **Kummer-Dedekind Theorem** in the monogenic case, stating that the
    bijection `FactorsEquiv'` defined in the first half preserves multiplicities. -/
theorem multiplicity_factors_map_eq_multiplicity (hI : IsMaximal I) (hI' : I ≠ ⊥)
    (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤) (hx' : IsIntegral R x) {J : Ideal S}
    (hJ : J ∈ normalizedFactors (I.map (algebraMap R S))) :
    multiplicity J (I.map (algebraMap R S)) =
      multiplicity (↑(normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx' ⟨J, hJ⟩))
        (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x)) 
goal: multiplicity J (Ideal.map (algebraMap R S) I) =
  multiplicity (↑((KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx') ⟨J, hJ⟩))
    (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))

full_name: KummerDedekind.normalizedFactors_ideal_map_eq_normalizedFactors_min_poly_mk_map
code: /-- The **Kummer-Dedekind Theorem**. -/
theorem normalizedFactors_ideal_map_eq_normalizedFactors_min_poly_mk_map (hI : IsMaximal I)
    (hI' : I ≠ ⊥) (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤) (hx' : IsIntegral R x) :
    normalizedFactors (I.map (algebraMap R S)) =
      Multiset.map
        (fun f =>
          ((normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx').symm f : Ideal S))
        (normalizedFactors (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))).attach 
goal: UniqueFactorizationMonoid.normalizedFactors (Ideal.map (algebraMap R S) I) =
  Multiset.map (fun f => ↑((KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx').symm f))
    (UniqueFactorizationMonoid.normalizedFactors (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))).attach

full_name: KummerDedekind.Ideal.irreducible_map_of_irreducible_minpoly
code: theorem Ideal.irreducible_map_of_irreducible_minpoly (hI : IsMaximal I) (hI' : I ≠ ⊥)
    (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤) (hx' : IsIntegral R x)
    (hf : Irreducible (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))) :
    Irreducible (I.map (algebraMap R S)) 
goal: Irreducible (Ideal.map (algebraMap R S) I)