fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
count_maximal (w : HeightOneSpectrum R) [Decidable (w = v)] :
count K v (w.asIdeal : FractionalIdeal R⁰ K) = if w = v then 1 else 0 := by
split_ifs with h
· rw [h, count_self]
· exact count_maximal_coprime K v h | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_maximal | null |
count_finprod_coprime (exps : HeightOneSpectrum R → ℤ) :
count K v (∏ᶠ (w : HeightOneSpectrum R) (_ : w ≠ v),
(w.asIdeal : (FractionalIdeal R⁰ K)) ^ exps w) = 0 := by
apply finprod_mem_induction fun I => count K v I = 0
· exact count_one K v
· intro I I' hI hI'
classical
by_cases h : I ≠ 0 ∧ I' ≠ 0
· rw [count_mul' K v, if_pos h, hI, hI', add_zero]
· rw [count_mul' K v, if_neg h]
· intro w hw
rw [count_zpow, count_maximal_coprime K v hw, mul_zero] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_finprod_coprime | `val_v(∏_{w ≠ v} w^{exps w}) = 0`. |
count_finsuppProd (exps : HeightOneSpectrum R →₀ ℤ) :
count K v (exps.prod (HeightOneSpectrum.asIdeal · ^ ·)) = exps v := by
rw [Finsupp.prod, count_prod]
· classical simp only [count_zpow, count_maximal, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq',
exps.mem_support_iff, ne_eq, ite_not, ite_eq_right_iff, @eq_comm ℤ 0, imp_self]
· exact fun v hv ↦ zpow_ne_zero _ (coeIdeal_ne_zero.mpr v.ne_bot)
@[deprecated (since := "2025-04-06")] alias count_finsupp_prod := count_finsuppProd | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_finsuppProd | null |
count_finprod (exps : HeightOneSpectrum R → ℤ)
(h_exps : ∀ᶠ v : HeightOneSpectrum R in Filter.cofinite, exps v = 0) :
count K v (∏ᶠ v : HeightOneSpectrum R,
(v.asIdeal : FractionalIdeal R⁰ K) ^ exps v) = exps v := by
convert count_finsuppProd K v (Finsupp.mk h_exps.toFinset exps (fun _ ↦ h_exps.mem_toFinset))
rw [finprod_eq_finset_prod_of_mulSupport_subset (s := h_exps.toFinset), Finsupp.prod]
· rfl
· rw [Finite.coe_toFinset]
intro v hv h
rw [mem_mulSupport, h, zpow_zero] at hv
exact hv (Eq.refl 1)
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_finprod | If `exps` is finitely supported, then `val_v(∏_w w^{exps w}) = exps v`. |
count_coe {J : Ideal R} (hJ : J ≠ 0) :
count K v J = (Associates.mk v.asIdeal).count (Associates.mk J).factors := by
rw [count_well_defined K (J := J) (a := 1), Ideal.span_singleton_one, sub_eq_self,
Nat.cast_eq_zero, ← Ideal.one_eq_top, Associates.mk_one, Associates.factors_one,
Associates.count_zero v.associates_irreducible]
· simpa only [ne_eq, coeIdeal_eq_zero]
· simp only [map_one, inv_one, spanSingleton_one, one_mul] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_coe | null |
count_coe_nonneg (J : Ideal R) : 0 ≤ count K v J := by
by_cases hJ : J = 0
· simp only [hJ, Submodule.zero_eq_bot, coeIdeal_bot, count_zero, le_refl]
· classical simp only [count_coe K v hJ, Nat.cast_nonneg] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_coe_nonneg | null |
count_mono {I J} (hI : I ≠ 0) (h : I ≤ J) : count K v J ≤ count K v I := by
by_cases hJ : J = 0
· exact (hI (FractionalIdeal.le_zero_iff.mp (h.trans hJ.le))).elim
have := mul_le_mul_left' h J⁻¹
rw [inv_mul_cancel₀ hJ, FractionalIdeal.le_one_iff_exists_coeIdeal] at this
obtain ⟨J', hJ'⟩ := this
rw [← mul_inv_cancel_left₀ hJ I, ← hJ', count_mul K v hJ, le_add_iff_nonneg_right]
· exact count_coe_nonneg K v J'
· exact hJ' ▸ mul_ne_zero (inv_ne_zero hJ) hI | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_mono | null |
finprod_heightOneSpectrum_factorization' {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) :
∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^ (count K v I) = I := by
have h := (Classical.choose_spec (Classical.choose_spec (exists_eq_spanSingleton_mul I))).2
conv_rhs => rw [← finprod_heightOneSpectrum_factorization hI h]
apply finprod_congr
intro w
apply congr_arg
rw [count_ne_zero K w hI]
variable {K}
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_heightOneSpectrum_factorization' | If `I` is a nonzero fractional ideal, then `I` is equal to the product `∏_v v^(count K v I)`. |
finite_factors' {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R}
{J : Ideal R} (haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
∀ᶠ v : HeightOneSpectrum R in Filter.cofinite,
((Associates.mk v.asIdeal).count (Associates.mk J).factors : ℤ) -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors = 0 := by
have ha_ne_zero : Ideal.span {a} ≠ 0 := constant_factor_ne_zero hI haJ
have hJ_ne_zero : J ≠ 0 := ideal_factor_ne_zero hI haJ
have h_subset :
{v : HeightOneSpectrum R | ¬((Associates.mk v.asIdeal).count (Associates.mk J).factors : ℤ) -
↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors) = 0} ⊆
{v : HeightOneSpectrum R | v.asIdeal ∣ J} ∪
{v : HeightOneSpectrum R | v.asIdeal ∣ Ideal.span {a}} := by
intro v hv
have hv_irred : Irreducible v.asIdeal := v.irreducible
by_contra h_notMem
rw [mem_union, mem_setOf_eq, mem_setOf_eq] at h_notMem
push_neg at h_notMem
rw [← Associates.count_ne_zero_iff_dvd ha_ne_zero hv_irred, not_not,
← Associates.count_ne_zero_iff_dvd hJ_ne_zero hv_irred, not_not] at h_notMem
rw [mem_setOf_eq, h_notMem.1, h_notMem.2, sub_self] at hv
exact hv (Eq.refl 0)
exact Finite.subset (Finite.union (Ideal.finite_factors (ideal_factor_ne_zero hI haJ))
(Ideal.finite_factors (constant_factor_ne_zero hI haJ))) h_subset
open Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finite_factors' | If `I ≠ 0`, then `val_v(I) = 0` for all but finitely many maximal ideals of `R`. |
finite_factors (I : FractionalIdeal R⁰ K) :
∀ᶠ v : HeightOneSpectrum R in Filter.cofinite, count K v I = 0 := by
by_cases hI : I = 0
· simp only [hI, count_zero, Filter.eventually_cofinite, not_true_eq_false, setOf_false,
finite_empty]
· convert finite_factors' hI (choose_spec (choose_spec (exists_eq_spanSingleton_mul I))).2
rw [count_ne_zero K _ hI] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finite_factors | `val_v(I) = 0` for all but finitely many maximal ideals of `R`. |
IsDedekindDomain.exists_sup_span_eq {I J : Ideal R} (hIJ : I ≤ J) (hI : I ≠ 0) :
∃ a, I ⊔ Ideal.span {a} = J := by
classical
obtain ⟨I, rfl⟩ := Ideal.dvd_iff_le.mpr hIJ
simp only [ne_eq, mul_eq_zero, not_or] at hI
obtain ⟨hJ, hI⟩ := hI
suffices ∃ a, ∃ K, J * K = Ideal.span {a} ∧ I + K = ⊤ by
obtain ⟨a, K, e, e'⟩ := this
exact ⟨a, by rw [← e, ← Ideal.add_eq_sup, ← mul_add, e', Ideal.mul_top]⟩
let s := (I.finite_factors hI).toFinset
have : ∀ p ∈ s, J * ∏ q ∈ s, q.asIdeal < J * ∏ q ∈ s \ {p}, q.asIdeal := by
intro p hps
conv_rhs => rw [← mul_one (J * _)]
rw [Finset.prod_eq_mul_prod_diff_singleton hps, ← mul_assoc,
mul_right_comm _ p.asIdeal]
refine mul_lt_mul_of_pos_left ?_ ?_
· rw [Ideal.one_eq_top, lt_top_iff_ne_top]
exact p.2.ne_top
· rw [Ideal.zero_eq_bot, bot_lt_iff_ne_bot, ← Ideal.zero_eq_bot,
mul_ne_zero_iff, Finset.prod_ne_zero_iff]
exact ⟨hJ, fun x _ ↦ x.3⟩
choose! a ha ha' using fun p hps ↦ SetLike.exists_of_lt (this p hps)
obtain ⟨K, hK⟩ : J ∣ Ideal.span {∑ p ∈ s, a p} := by
rw [Ideal.dvd_iff_le, Ideal.span_singleton_le_iff_mem]
exact sum_mem fun p hp ↦ Ideal.mul_le_right (ha p hp)
refine ⟨_, _, hK.symm, ?_⟩
by_contra H
obtain ⟨p, hp, h⟩ := Ideal.exists_le_maximal _ H
let p' : HeightOneSpectrum R := ⟨p, hp.isPrime, fun e ↦ hI (by simp_all)⟩
have hp's : p' ∈ s := by simpa [p', s, Ideal.dvd_iff_le] using le_sup_left.trans h
have H₁ : J * K ≤ J * p := Ideal.mul_mono_right (le_sup_right.trans h)
replace H₁ := hK.trans_le H₁ (Ideal.mem_span_singleton_self _)
have H₂ : ∑ q ∈ s \ {p'}, a q ∈ J * p := by
refine sum_mem fun q hq ↦ ?_
rw [Finset.mem_sdiff, Finset.mem_singleton] at hq
refine Ideal.mul_mono_right ?_ (ha q hq.1)
exact Ideal.prod_le_inf.trans (Finset.inf_le (b := p') (by simpa [hp's] using Ne.symm hq.2))
apply ha' _ hp's
have := IsDedekindDomain.inf_prime_pow_eq_prod s (fun i ↦ i.asIdeal) (fun _ ↦ 1)
(fun i _ ↦ i.prime) (fun i _ j _ e ↦ mt HeightOneSpectrum.ext e)
simp only [pow_one] at this
have inst : Nonempty {x // x ∈ s} := ⟨_, hp's⟩
rw [← this, Finset.inf_eq_iInf, iInf_subtype', Ideal.mul_iInf, Ideal.mem_iInf]
rintro ⟨q, hq⟩
by_cases hqp : q = p'
· subst hqp
convert sub_mem H₁ H₂
rw [Finset.sum_eq_add_sum_diff_singleton hp's, add_sub_cancel_right]
· refine Ideal.mul_mono_right ?_ (ha p' hp's)
exact Ideal.prod_le_inf.trans (Finset.inf_le (b := q) (by simpa [hq] using hqp)) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | IsDedekindDomain.exists_sup_span_eq | In a Dedekind domain, for every ideals `0 < I ≤ J` there exists `a` such that `J = I + ⟨a⟩`.
TODO: Show that this property uniquely characterizes Dedekind domains. |
IsDedekindDomain.exists_eq_span_pair {I : Ideal R} {x : R} (hxI : x ∈ I) (hx : x ≠ 0) :
∃ y, I = .span {x, y} := by
obtain ⟨y, rfl⟩ := exists_sup_span_eq (I.span_singleton_le_iff_mem.mpr hxI) (by simpa)
simp_rw [← Ideal.span_union, Set.union_singleton, Set.pair_comm x]
use y | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | IsDedekindDomain.exists_eq_span_pair | In a Dedekind domain, any ideal is spanned by two elements, where one of the element
could be any fixed non-zero element in the ideal. |
IsDedekindDomain.exists_add_spanSingleton_mul_eq
{a b c : FractionalIdeal R⁰ K} (hac : a ≤ c) (ha : a ≠ 0) (hb : b ≠ 0) :
∃ x : K, a + FractionalIdeal.spanSingleton R⁰ x * b = c := by
wlog hb' : b = 1
· obtain ⟨x, e⟩ := this (a := b⁻¹ * a) (b := 1) (c := b⁻¹ * c)
(mul_le_mul_left' hac _) (by simp [ha, hb]) one_ne_zero rfl
use x
simpa [hb, ← mul_assoc, mul_add, mul_comm b (.spanSingleton _ _)] using congr(b * $e)
subst hb'
have H : Ideal.span {c.den.1} * a.num ≤ c.num * Ideal.span {a.den.1} := by
rw [← FractionalIdeal.coeIdeal_le_coeIdeal K]
simp only [FractionalIdeal.coeIdeal_mul, FractionalIdeal.coeIdeal_span_singleton, ←
FractionalIdeal.den_mul_self_eq_num']
ring_nf
exact mul_le_mul_left' hac _
obtain ⟨x, hx⟩ := exists_sup_span_eq H
(by simpa using FractionalIdeal.num_eq_zero_iff.not.mpr ha)
refine ⟨algebraMap R K x / algebraMap R K (a.den.1 * c.den.1), ?_⟩
refine mul_left_injective₀ (b := .spanSingleton _
(algebraMap R K (a.den.1 * c.den.1))) ?_ ?_
· simp [FractionalIdeal.spanSingleton_eq_zero_iff]
· simp only [map_mul, mul_one, add_mul, FractionalIdeal.spanSingleton_mul_spanSingleton,
isUnit_iff_ne_zero, ne_eq, mul_eq_zero, FaithfulSMul.algebraMap_eq_zero_iff,
nonZeroDivisors.coe_ne_zero, or_self, not_false_eq_true, IsUnit.div_mul_cancel]
rw [← FractionalIdeal.spanSingleton_mul_spanSingleton, ← mul_assoc, mul_comm a,
FractionalIdeal.den_mul_self_eq_num', ← mul_assoc, mul_right_comm,
mul_comm c, FractionalIdeal.den_mul_self_eq_num', mul_comm]
simp_rw [← FractionalIdeal.coeIdeal_span_singleton, ← FractionalIdeal.coeIdeal_mul,
← hx, ← FractionalIdeal.coeIdeal_sup] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | IsDedekindDomain.exists_add_spanSingleton_mul_eq | null |
noncomputable
divMod (c b a : FractionalIdeal R⁰ K) : K :=
letI := Classical.propDecidable
if h : a ≤ c ∧ a ≠ 0 ∧ b ≠ 0 then
(IsDedekindDomain.exists_add_spanSingleton_mul_eq h.1 h.2.1 h.2.2).choose else 0 | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | divMod | `c.divMod b a` (i.e. `c / b mod a`) is an arbitrary `x` such that `c = bx + a`.
This is zero if the above is not possible, i.e. when `a = 0` or `b = 0` or `¬ a ≤ c`. |
divMod_spec
{a b c : FractionalIdeal R⁰ K} (hac : a ≤ c) (ha : a ≠ 0) (hb : b ≠ 0) :
a + spanSingleton R⁰ (c.divMod b a) * b = c := by
rw [divMod, dif_pos ⟨hac, ha, hb⟩]
exact (IsDedekindDomain.exists_add_spanSingleton_mul_eq hac ha hb).choose_spec
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | divMod_spec | null |
divMod_zero_left {I J : FractionalIdeal R⁰ K} : I.divMod 0 J = 0 := by
simp [divMod]
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | divMod_zero_left | null |
divMod_zero_right {I J : FractionalIdeal R⁰ K} : I.divMod J 0 = 0 := by
simp [divMod]
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | divMod_zero_right | null |
zero_divMod {I J : FractionalIdeal R⁰ K} :
(0 : FractionalIdeal R⁰ K).divMod I J = 0 := by
simp [divMod, ← and_assoc] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | zero_divMod | null |
divMod_zero_of_not_le {a b c : FractionalIdeal R⁰ K} (hac : ¬ a ≤ c) :
c.divMod b a = 0 := by
simp [divMod, hac]
set_option maxHeartbeats 210000 in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | divMod_zero_of_not_le | null |
noncomputable
quotientEquiv (I J I' J' : FractionalIdeal R⁰ K)
(H : I * J' = I' * J) (h : J ≤ I) (h' : J' ≤ I') (hJ' : J' ≠ 0) (hI : I ≠ 0) :
(I ⧸ J.coeToSubmodule.comap I.coeToSubmodule.subtype) ≃ₗ[R]
I' ⧸ J'.coeToSubmodule.comap I'.coeToSubmodule.subtype := by
haveI : J' ⊓ spanSingleton R⁰ (I'.divMod I J') * I = spanSingleton R⁰ (I'.divMod I J') * J := by
have := FractionalIdeal.sup_mul_inf J' (spanSingleton R⁰ (I'.divMod I J') * I)
rwa [FractionalIdeal.sup_eq_add, divMod_spec h' hJ' hI, mul_left_comm, mul_comm J' I, H,
mul_comm I' J, ← mul_assoc, (mul_left_injective₀ _).eq_iff] at this
rintro rfl
exact hJ' (by simpa using h')
refine .ofBijective (Submodule.mapQ _ _ (LinearMap.restrict
(Algebra.lsmul R _ _ (I'.divMod I J')) ?_) ?_) ⟨?_, ?_⟩
· intro x hx
refine (divMod_spec h' hJ' hI).le ?_
exact Submodule.mem_sup_right (mul_mem_mul (mem_spanSingleton_self _ _) hx)
· rw [← Submodule.comap_comp, LinearMap.subtype_comp_restrict, LinearMap.domRestrict,
Submodule.comap_comp]
refine Submodule.comap_mono ?_
intro x hx
refine (Submodule.mem_inf.mp (this.ge ?_)).1
simp only [val_eq_coe, Algebra.lsmul_coe, smul_eq_mul, mem_coe]
exact mul_mem_mul (mem_spanSingleton_self _ _) hx
· rw [← LinearMap.ker_eq_bot, Submodule.mapQ, Submodule.ker_liftQ,
LinearMap.ker_comp, Submodule.ker_mkQ, ← Submodule.comap_comp,
LinearMap.subtype_comp_restrict, ← le_bot_iff, Submodule.map_le_iff_le_comap,
Submodule.comap_bot, Submodule.ker_mkQ, LinearMap.domRestrict,
Submodule.comap_comp, ← Submodule.map_le_iff_le_comap,
Submodule.map_comap_eq, Submodule.range_subtype]
by_cases H' : I'.divMod I J' = 0
· obtain rfl : J' = I' := by simpa [H'] using divMod_spec h' hJ' hI
obtain rfl : I = J := mul_left_injective₀ hJ' (H.trans (mul_comm _ _))
exact inf_le_left
rw [← inv_mul_eq_iff_eq_mul₀ (by simpa [spanSingleton_eq_zero_iff] using H'), mul_inf₀
(zero_le _), inv_mul_cancel_left₀ (by simpa [spanSingleton_eq_zero_iff] using H')] at this
rw [← this, inf_comm, coe_inf]
refine inf_le_inf ?_ le_rfl
intro x hx
rw [spanSingleton_inv]
convert mul_mem_mul (mem_spanSingleton_self _ _) hx
simp [H']
· have H : Submodule.map (Algebra.lsmul R R K (I'.divMod I J')) ↑I =
(spanSingleton R⁰ (I'.divMod I J') * I) := by
ext x
simp [Submodule.mem_span_singleton_mul]
rw [← LinearMap.range_eq_top, Submodule.mapQ, Submodule.range_liftQ,
LinearMap.range_comp, LinearMap.restrict, LinearMap.range_codRestrict,
LinearMap.range_domRestrict, ← top_le_iff, H,
← LinearMap.range_eq_top.mpr (Submodule.mkQ_surjective _),
← Submodule.map_top, Submodule.map_le_iff_le_comap, Submodule.comap_map_eq, Submodule.ker_mkQ,
← Submodule.map_le_map_iff_of_injective I'.coeToSubmodule.injective_subtype,
... | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | quotientEquiv | Let `I J I' J'` be nonzero fractional ideals in a Dedekind domain with `J ≤ I` and `J' ≤ I'`.
If `I/J = I'/J'` in the group of fractional ideals (i.e. `I * J' = I' * J`),
then `I/J ≃ I'/J'` as quotient `R`-modules. |
Ideal.map_algebraMap_eq_finset_prod_pow {p : Ideal S} [p.IsMaximal] (hp : p ≠ 0) :
map (algebraMap S R) p = ∏ P ∈ p.primesOver R, P ^ p.ramificationIdx (algebraMap S R) P := by
classical
have h : map (algebraMap S R) p ≠ 0 := map_ne_bot_of_ne_bot hp
rw [← finprod_heightOneSpectrum_factorization (I := p.map (algebraMap S R)) h]
let hF : Fintype {v : HeightOneSpectrum R | v.asIdeal ∣ map (algebraMap S R) p} :=
(finite_factors h).fintype
rw [finprod_eq_finset_prod_of_mulSupport_subset
(s := {v | v.asIdeal ∣ p.map (algebraMap S R)}.toFinset), ← Finset.prod_set_coe,
← Finset.prod_set_coe]
· let _ : Fintype {v : HeightOneSpectrum R // v.asIdeal ∣ map (algebraMap S R) p} := hF
refine Fintype.prod_equiv (equivPrimesOver _ hp) _ _ fun ⟨v, _⟩ ↦ ?_
simp [maxPowDividing_eq_pow_multiset_count _ h,
ramificationIdx_eq_factors_count h v.isPrime v.ne_bot]
· intro v hv
simpa [maxPowDividing, Function.mem_mulSupport, IsPrime.ne_top _,
Associates.count_ne_zero_iff_dvd h (irreducible v)] using hv | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | Ideal.map_algebraMap_eq_finset_prod_pow | If `p` is a maximal ideal, then the lift of `p` in an extension is the product of the primes
over `p` to the power the ramification index. |
HeightOneSpectrum.Support (k : K) : Set (HeightOneSpectrum R) :=
{v : HeightOneSpectrum R | 1 < v.valuation K k} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DedekindDomain.Factorization",
"Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace"
] | Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean | HeightOneSpectrum.Support | The support of an element `k` of the field of fractions of a Dedekind domain is
the set of maximal ideals of the Dedekind domain at which `k` is not integral. |
HeightOneSpectrum.Support.finite (k : K) : (Support R k).Finite := by
obtain ⟨⟨n, ⟨d, hd⟩⟩, hk⟩ := IsLocalization.surj (nonZeroDivisors R) k
have hd' : d ≠ 0 := nonZeroDivisors.ne_zero hd
suffices {v : HeightOneSpectrum R | v.valuation K (algebraMap R K d) < 1}.Finite by
apply Set.Finite.subset this
intro v hv
apply_fun v.valuation K at hk
simp only [Valuation.map_mul, valuation_of_algebraMap] at hk
rw [Set.mem_setOf_eq, valuation_of_algebraMap]
have := intValuation_le_one v n
contrapose! this
rw [← hk, mul_comm]
exact (lt_mul_of_one_lt_right (by simp) hv).trans_le <|
mul_le_mul_of_nonneg_right this (by simp)
simp_rw [valuation_lt_one_iff_dvd]
apply Ideal.finite_factors
simpa only [Submodule.zero_eq_bot, ne_eq, Ideal.span_singleton_eq_bot] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DedekindDomain.Factorization",
"Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace"
] | Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean | HeightOneSpectrum.Support.finite | The support of an element of the field of fractions of a Dedekind domain
is finite. |
FiniteAdeleRing : Type _ :=
Πʳ v : HeightOneSpectrum R, [v.adicCompletion K, v.adicCompletionIntegers K] | abbrev | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DedekindDomain.Factorization",
"Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace"
] | Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean | FiniteAdeleRing | If `K` is the field of fractions of the Dedekind domain `R` then `FiniteAdeleRing R K` is
the ring of finite adeles of `K`, defined as the restricted product of the completions
`K_v` with respect to the subrings `R_v`. Here `v` runs through the nonzero primes of `R`
and the restricted product is the subring of `∏_v K_v` consisting of elements which
are in `R_v` for all but finitely many `v`. |
protected algebraMap : K →+* FiniteAdeleRing R K where
toFun k := ⟨fun i ↦ k, by
simp only [Filter.eventually_cofinite, SetLike.mem_coe, mem_adicCompletionIntegers R K,
adicCompletion, Valued.valuedCompletion_apply, not_le]
exact HeightOneSpectrum.Support.finite R k⟩
map_one' := rfl
map_mul' x y := Subtype.eq <| funext (fun v ↦
UniformSpace.Completion.coe_mul ((WithVal.equiv (valuation K v)).symm x) y)
map_zero' := rfl
map_add' x y := Subtype.eq <| funext (fun v ↦
UniformSpace.Completion.coe_add ((WithVal.equiv (valuation K v)).symm x) y) | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DedekindDomain.Factorization",
"Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace"
] | Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean | algebraMap | The canonical map from `K` to the finite adeles of `K`.
The content of the existence of this map is the fact that an element `k` of `K` is integral at
all but finitely many places, which is `IsDedekindDomain.HeightOneSpectrum.Support.finite R k`. |
@[ext]
ext {a₁ a₂ : FiniteAdeleRing R K} (h : ∀ v, a₁ v = a₂ v) : a₁ = a₂ :=
Subtype.ext <| funext h | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DedekindDomain.Factorization",
"Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace"
] | Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean | ext | null |
algebraMapSubmonoid_le_nonZeroDivisors_of_faithfulSMul {A : Type*} (B : Type*)
[CommSemiring A] [CommSemiring B] [Algebra A B] [NoZeroDivisors B] [FaithfulSMul A B]
{S : Submonoid A} (hS : S ≤ A⁰) : algebraMapSubmonoid B S ≤ B⁰ :=
map_le_nonZeroDivisors_of_injective _ (FaithfulSMul.algebraMap_injective A B) hS
variable (Rₘ Sₘ : Type*) [CommRing Rₘ] [CommRing Sₘ] [Algebra R Rₘ] [NoZeroSMulDivisors R S]
[Algebra.IsSeparable (FractionRing R) (FractionRing S)] {M : Submonoid R} [IsLocalization M Rₘ]
[Algebra Rₘ Sₘ] [Algebra S Sₘ] [Algebra R Sₘ] [IsScalarTower R Rₘ Sₘ]
[IsScalarTower R S Sₘ] [IsLocalization (algebraMapSubmonoid S M) Sₘ]
[Algebra (FractionRing Rₘ) (FractionRing Sₘ)]
[IsScalarTower Rₘ (FractionRing Rₘ) (FractionRing Sₘ)]
include R S in | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.PID",
"Mathlib.FieldTheory.Separable",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/Instances.lean | algebraMapSubmonoid_le_nonZeroDivisors_of_faithfulSMul | null |
FractionRing.isSeparable_of_isLocalization (hM : M ≤ R⁰) :
Algebra.IsSeparable (FractionRing Rₘ) (FractionRing Sₘ) := by
let M' := algebraMapSubmonoid S M
have hM' : algebraMapSubmonoid S M ≤ S⁰ := algebraMapSubmonoid_le_nonZeroDivisors_of_faithfulSMul
_ hM
let f₁ : Rₘ →+* K := map _ (T := R⁰) (RingHom.id R) hM
let f₂ : Sₘ →+* L := map _ (T := S⁰) (RingHom.id S) hM'
algebraize [f₁, f₂]
have := localization_isScalarTower_of_submonoid_le Rₘ K _ _ hM
have := localization_isScalarTower_of_submonoid_le Sₘ L _ _ hM'
have := isFractionRing_of_isDomain_of_isLocalization M Rₘ K
have := isFractionRing_of_isDomain_of_isLocalization M' Sₘ L
have : IsDomain Rₘ := isDomain_of_le_nonZeroDivisors _ hM
apply Algebra.IsSeparable.of_equiv_equiv (FractionRing.algEquiv Rₘ K).symm.toRingEquiv
(FractionRing.algEquiv Sₘ L).symm.toRingEquiv
apply ringHom_ext R⁰
ext
simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp,
RingHom.coe_coe, Function.comp_apply, ← algebraMap_apply]
rw [algebraMap_apply R Rₘ (FractionRing R), AlgEquiv.coe_ringEquiv, AlgEquiv.commutes,
algebraMap_apply R S L, algebraMap_apply S Sₘ L, AlgEquiv.coe_ringEquiv, AlgEquiv.commutes]
simp only [← algebraMap_apply]
rw [algebraMap_apply R Rₘ (FractionRing Rₘ), ← algebraMap_apply Rₘ, ← algebraMap_apply] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.PID",
"Mathlib.FieldTheory.Separable",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/Instances.lean | FractionRing.isSeparable_of_isLocalization | null |
noncomputable Localization.AtPrime.liftAlgebra : Algebra Sₚ L :=
(map _ (T := S⁰) (RingHom.id S)
(algebraMapSubmonoid_le_nonZeroDivisors_of_faithfulSMul _
P.primeCompl_le_nonZeroDivisors)).toAlgebra
attribute [local instance] Localization.AtPrime.liftAlgebra | abbrev | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.PID",
"Mathlib.FieldTheory.Separable",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/Instances.lean | Localization.AtPrime.liftAlgebra | This is not an instance because it creates a diamond with `OreLocalization.instAlgebra`. |
noncomputable Localization.AtPrime.algebra_localization_localization :
Algebra Sₚ Tₚ := localizationAlgebra P' T
attribute [local instance] Localization.AtPrime.algebra_localization_localization | abbrev | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.PID",
"Mathlib.FieldTheory.Separable",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/Instances.lean | Localization.AtPrime.algebra_localization_localization | Let `R ⊆ S ⊆ T` be a tower of rings. Let `Sₚ` and `Tₚ` denote the localizations of `S` and `T` at
the prime ideal `P` of `R`. Then `Tₚ` is a `Sₚ`-algebra.
This cannot be an instance since it creates a diamond when `S = T`. |
IsIntegralClosure.isLocalization [IsDomain A] [Algebra.IsAlgebraic K L] :
IsLocalization (Algebra.algebraMapSubmonoid C A⁰) L := by
haveI : IsDomain C :=
(IsIntegralClosure.equiv A C L (integralClosure A L)).toMulEquiv.isDomain (integralClosure A L)
haveI : NoZeroSMulDivisors A L := NoZeroSMulDivisors.trans_faithfulSMul A K L
haveI : NoZeroSMulDivisors A C := IsIntegralClosure.noZeroSMulDivisors A L
refine ⟨?_, fun z => ?_, fun {x y} h => ⟨1, ?_⟩⟩
· rintro ⟨_, x, hx, rfl⟩
rw [isUnit_iff_ne_zero, map_ne_zero_iff _ (IsIntegralClosure.algebraMap_injective C A L),
Subtype.coe_mk, map_ne_zero_iff _ (FaithfulSMul.algebraMap_injective A C)]
exact mem_nonZeroDivisors_iff_ne_zero.mp hx
· obtain ⟨m, hm⟩ :=
IsIntegral.exists_multiple_integral_of_isLocalization A⁰ z
(Algebra.IsIntegral.isIntegral (R := K) z)
obtain ⟨x, hx⟩ : ∃ x, algebraMap C L x = m • z := IsIntegralClosure.isIntegral_iff.mp hm
refine ⟨⟨x, algebraMap A C m, m, SetLike.coe_mem m, rfl⟩, ?_⟩
rw [Subtype.coe_mk, ← IsScalarTower.algebraMap_apply, hx, mul_comm, Submonoid.smul_def,
smul_def]
· simp only [IsIntegralClosure.algebraMap_injective C A L h] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.isLocalization | If `L` is an algebraic extension of `K = Frac(A)` and `L` has no zero smul divisors by `A`,
then `L` is the localization of the integral closure `C` of `A` in `L` at `A⁰`. |
IsIntegralClosure.isLocalization_of_isSeparable [IsDomain A] [Algebra.IsSeparable K L] :
IsLocalization (Algebra.algebraMapSubmonoid C A⁰) L :=
IsIntegralClosure.isLocalization A K L C
variable [FiniteDimensional K L]
variable {A K L} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.isLocalization_of_isSeparable | null |
IsIntegralClosure.range_le_span_dualBasis [Algebra.IsSeparable K L] {ι : Type*} [Fintype ι]
[DecidableEq ι] (b : Basis ι K L) (hb_int : ∀ i, IsIntegral A (b i)) [IsIntegrallyClosed A] :
LinearMap.range ((Algebra.linearMap C L).restrictScalars A) ≤
Submodule.span A (Set.range <| (traceForm K L).dualBasis (traceForm_nondegenerate K L) b) := by
rw [← LinearMap.BilinForm.dualSubmodule_span_of_basis,
← LinearMap.BilinForm.le_flip_dualSubmodule, Submodule.span_le]
rintro _ ⟨i, rfl⟩ _ ⟨y, rfl⟩
simp only [LinearMap.coe_restrictScalars, linearMap_apply, LinearMap.BilinForm.flip_apply,
traceForm_apply]
refine Submodule.mem_one.mpr <| IsIntegrallyClosed.isIntegral_iff.mp ?_
exact isIntegral_trace ((IsIntegralClosure.isIntegral A L y).algebraMap.mul (hb_int i)) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.range_le_span_dualBasis | null |
integralClosure_le_span_dualBasis [Algebra.IsSeparable K L] {ι : Type*} [Fintype ι]
[DecidableEq ι] (b : Basis ι K L) (hb_int : ∀ i, IsIntegral A (b i)) [IsIntegrallyClosed A] :
Subalgebra.toSubmodule (integralClosure A L) ≤
Submodule.span A (Set.range <| (traceForm K L).dualBasis (traceForm_nondegenerate K L) b) := by
refine le_trans ?_ (IsIntegralClosure.range_le_span_dualBasis (integralClosure A L) b hb_int)
intro x hx
exact ⟨⟨x, hx⟩, rfl⟩
variable [IsDomain A]
variable (A K) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | integralClosure_le_span_dualBasis | null |
exists_integral_multiples (s : Finset L) :
∃ y ≠ (0 : A), ∀ x ∈ s, IsIntegral A (y • x) :=
have := IsLocalization.isAlgebraic K (nonZeroDivisors A)
have := Algebra.IsAlgebraic.trans A K L
Algebra.IsAlgebraic.exists_integral_multiples ..
variable (L) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | exists_integral_multiples | Send a set of `x`s in a finite extension `L` of the fraction field of `R`
to `(y : R) • x ∈ integralClosure R L`. |
FiniteDimensional.exists_is_basis_integral :
∃ (s : Finset L) (b : Basis s K L), ∀ x, IsIntegral A (b x) := by
letI := Classical.decEq L
letI : IsNoetherian K L := IsNoetherian.iff_fg.2 inferInstance
let s' := IsNoetherian.finsetBasisIndex K L
let bs' := IsNoetherian.finsetBasis K L
obtain ⟨y, hy, his'⟩ := exists_integral_multiples A K (Finset.univ.image bs')
have hy' : algebraMap A L y ≠ 0 := by
refine mt ((injective_iff_map_eq_zero (algebraMap A L)).mp ?_ _) hy
rw [IsScalarTower.algebraMap_eq A K L]
exact (algebraMap K L).injective.comp (IsFractionRing.injective A K)
refine ⟨s', bs'.map {Algebra.lmul _ _ (algebraMap A L y) with
toFun := fun x => algebraMap A L y * x
invFun := fun x => (algebraMap A L y)⁻¹ * x
left_inv := ?_
right_inv := ?_}, ?_⟩
· intro x; simp only [inv_mul_cancel_left₀ hy']
· intro x; simp only [mul_inv_cancel_left₀ hy']
· rintro ⟨x', hx'⟩
simp only [Algebra.smul_def, Finset.mem_image, Finset.mem_univ,
true_and] at his'
simp only [Basis.map_apply, LinearEquiv.coe_mk]
exact his' _ ⟨_, rfl⟩
variable [Algebra.IsSeparable K L] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | FiniteDimensional.exists_is_basis_integral | If `L` is a finite extension of `K = Frac(A)`,
then `L` has a basis over `A` consisting of integral elements. |
IsIntegralClosure.isNoetherian [IsIntegrallyClosed A] [IsNoetherianRing A] :
IsNoetherian A C := by
haveI := Classical.decEq L
obtain ⟨s, b, hb_int⟩ := FiniteDimensional.exists_is_basis_integral A K L
let b' := (traceForm K L).dualBasis (traceForm_nondegenerate K L) b
letI := isNoetherian_span_of_finite A (Set.finite_range b')
let f : C →ₗ[A] Submodule.span A (Set.range b') :=
(Submodule.inclusion (IsIntegralClosure.range_le_span_dualBasis C b hb_int)).comp
((Algebra.linearMap C L).restrictScalars A).rangeRestrict
refine isNoetherian_of_ker_bot f ?_
rw [LinearMap.ker_comp, Submodule.ker_inclusion, Submodule.comap_bot, LinearMap.ker_codRestrict]
exact LinearMap.ker_eq_bot_of_injective (IsIntegralClosure.algebraMap_injective C A L) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.isNoetherian | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
Noetherian over `A`. |
IsIntegralClosure.isNoetherianRing [IsIntegrallyClosed A] [IsNoetherianRing A] :
IsNoetherianRing C :=
isNoetherianRing_iff.mpr <| isNoetherian_of_tower A (IsIntegralClosure.isNoetherian A K L C) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.isNoetherianRing | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
Noetherian. |
IsIntegralClosure.finite [IsIntegrallyClosed A] [IsNoetherianRing A] :
Module.Finite A C := by
haveI := IsIntegralClosure.isNoetherian A K L C
exact Module.IsNoetherian.finite A C | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.finite | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
finite over `A`. |
IsIntegralClosure.module_free [NoZeroSMulDivisors A L] [IsPrincipalIdealRing A] :
Module.Free A C :=
haveI : NoZeroSMulDivisors A C := IsIntegralClosure.noZeroSMulDivisors A L
haveI : IsNoetherian A C := IsIntegralClosure.isNoetherian A K L _
inferInstance | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.module_free | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a principal ring
and `L` has no zero smul divisors by `A`, the integral closure `C` of `A` in `L` is
a free `A`-module. |
IsIntegralClosure.rank [IsPrincipalIdealRing A] [NoZeroSMulDivisors A L] :
Module.finrank A C = Module.finrank K L := by
haveI : Module.Free A C := IsIntegralClosure.module_free A K L C
haveI : IsNoetherian A C := IsIntegralClosure.isNoetherian A K L C
haveI : IsLocalization (Algebra.algebraMapSubmonoid C A⁰) L :=
IsIntegralClosure.isLocalization A K L C
let b := Basis.localizationLocalization K A⁰ L (Module.Free.chooseBasis A C)
rw [Module.finrank_eq_card_chooseBasisIndex, Module.finrank_eq_card_basis b]
variable {A K} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.rank | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a principal ring
and `L` has no zero smul divisors by `A`, the `A`-rank of the integral closure `C` of `A` in `L`
is equal to the `K`-rank of `L`. |
integralClosure.isNoetherianRing [IsIntegrallyClosed A] [IsNoetherianRing A] :
IsNoetherianRing (integralClosure A L) :=
IsIntegralClosure.isNoetherianRing A K L (integralClosure A L)
variable (A K) [IsDomain C] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | integralClosure.isNoetherianRing | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure of `A` in `L` is
Noetherian. |
IsIntegralClosure.isDedekindDomain [IsDedekindDomain A] : IsDedekindDomain C :=
have : IsFractionRing C L := IsIntegralClosure.isFractionRing_of_finite_extension A K L C
have : Algebra.IsIntegral A C := IsIntegralClosure.isIntegral_algebra A L
{ IsIntegralClosure.isNoetherianRing A K L C,
Ring.DimensionLEOne.isIntegralClosure A L C,
(isIntegrallyClosed_iff L).mpr fun {x} hx =>
⟨IsIntegralClosure.mk' C x (isIntegral_trans (R := A) _ hx),
IsIntegralClosure.algebraMap_mk' _ _ _⟩ with : IsDedekindDomain C } | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | IsIntegralClosure.isDedekindDomain | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a Dedekind domain,
the integral closure `C` of `A` in `L` is a Dedekind domain.
This cannot be an instance since `A`, `K` or `L` can't be inferred. See also the instance
`integralClosure.isDedekindDomain_fractionRing` where `K := FractionRing A`
and `C := integralClosure A L`. |
integralClosure.isDedekindDomain [IsDedekindDomain A] :
IsDedekindDomain (integralClosure A L) :=
IsIntegralClosure.isDedekindDomain A K L (integralClosure A L)
variable [Algebra (FractionRing A) L] [IsScalarTower A (FractionRing A) L]
variable [FiniteDimensional (FractionRing A) L] [Algebra.IsSeparable (FractionRing A) L] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | integralClosure.isDedekindDomain | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a Dedekind domain,
the integral closure of `A` in `L` is a Dedekind domain.
This cannot be an instance since `K` can't be inferred. See also the instance
`integralClosure.isDedekindDomain_fractionRing` where `K := FractionRing A`. |
integralClosure.isDedekindDomain_fractionRing [IsDedekindDomain A] :
IsDedekindDomain (integralClosure A L) :=
integralClosure.isDedekindDomain A (FractionRing A) L
attribute [local instance] FractionRing.liftAlgebra in | instance | RingTheory | [
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic",
"Mathlib.LinearAlgebra.BilinearForm.DualLattice",
"Mathlib.RingTheory.DedekindDomain.Basic",
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Trace.Basic",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean | integralClosure.isDedekindDomain_fractionRing | If `L` is a finite separable extension of `Frac(A)`, where `A` is a Dedekind domain,
the integral closure of `A` in `L` is a Dedekind domain.
See also the lemma `integralClosure.isDedekindDomain` where you can choose
the field of fractions yourself. |
Ideal.eq_span_singleton_of_mem_of_notMem_sq_of_notMem_prime_ne {P : Ideal R}
(hP : P.IsPrime) [IsDedekindDomain R] {x : R} (x_mem : x ∈ P) (hxP2 : x ∉ P ^ 2)
(hxQ : ∀ Q : Ideal R, IsPrime Q → Q ≠ P → x ∉ Q) : P = Ideal.span {x} := by
letI := Classical.decEq (Ideal R)
have hx0 : x ≠ 0 := by
rintro rfl
exact hxP2 (zero_mem _)
by_cases hP0 : P = ⊥
· subst hP0
rwa [eq_comm, span_singleton_eq_bot, ← mem_bot]
have hspan0 : span ({x} : Set R) ≠ ⊥ := mt Ideal.span_singleton_eq_bot.mp hx0
have span_le := (Ideal.span_singleton_le_iff_mem _).mpr x_mem
refine
associated_iff_eq.mp
((associated_iff_normalizedFactors_eq_normalizedFactors hP0 hspan0).mpr
(le_antisymm ((dvd_iff_normalizedFactors_le_normalizedFactors hP0 hspan0).mp ?_) ?_))
· rwa [Ideal.dvd_iff_le, Ideal.span_singleton_le_iff_mem]
simp only [normalizedFactors_irreducible (Ideal.prime_of_isPrime hP0 hP).irreducible,
normalize_eq, Multiset.le_iff_count, Multiset.count_singleton]
intro Q
split_ifs with hQ
· subst hQ
refine (Ideal.count_normalizedFactors_eq ?_ ?_).le <;>
simp only [Ideal.span_singleton_le_iff_mem, pow_one] <;>
assumption
by_cases hQp : IsPrime Q
· refine (Ideal.count_normalizedFactors_eq ?_ ?_).le <;>
simp [Ideal.span_singleton_le_iff_mem]
exact hxQ _ hQp hQ
· exact
(Multiset.count_eq_zero.mpr fun hQi =>
hQp
(isPrime_of_prime
(irreducible_iff_prime.mp (irreducible_of_normalized_factor _ hQi)))).le
@[deprecated (since := "2025-05-23")]
alias Ideal.eq_span_singleton_of_mem_of_not_mem_sq_of_not_mem_prime_ne :=
Ideal.eq_span_singleton_of_mem_of_notMem_sq_of_notMem_prime_ne | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | Ideal.eq_span_singleton_of_mem_of_notMem_sq_of_notMem_prime_ne | Let `P` be a prime ideal, `x ∈ P \ P²` and `x ∉ Q` for all prime ideals `Q ≠ P`.
Then `P` is generated by `x`. |
FractionalIdeal.isPrincipal_of_unit_of_comap_mul_span_singleton_eq_top {R A : Type*}
[CommRing R] [CommRing A] [Algebra R A] {S : Submonoid R} [IsLocalization S A]
(I : (FractionalIdeal S A)ˣ) {v : A} (hv : v ∈ (↑I⁻¹ : FractionalIdeal S A))
(h : Submodule.comap (Algebra.linearMap R A) ((I : Submodule R A) * Submodule.span R {v}) = ⊤) :
Submodule.IsPrincipal (I : Submodule R A) := by
have hinv := I.mul_inv
set J := Submodule.comap (Algebra.linearMap R A) ((I : Submodule R A) * Submodule.span R {v})
have hJ : IsLocalization.coeSubmodule A J = ↑I * Submodule.span R {v} := by
rw [coe_ext_iff, coe_mul, coe_one] at hinv
apply Submodule.map_comap_eq_self
rw [← Submodule.one_eq_range, ← hinv]
exact mul_le_mul_left' ((Submodule.span_singleton_le_iff_mem _ _).2 hv) _
have : (1 : A) ∈ ↑I * Submodule.span R {v} := by
rw [← hJ, h, IsLocalization.coeSubmodule_top, Submodule.mem_one]
exact ⟨1, (algebraMap R _).map_one⟩
obtain ⟨w, hw, hvw⟩ := Submodule.mem_mul_span_singleton.1 this
refine ⟨⟨w, ?_⟩⟩
rw [← FractionalIdeal.coe_spanSingleton S, ← inv_inv I, eq_comm]
refine congr_arg coeToSubmodule (Units.eq_inv_of_mul_eq_one_left (le_antisymm ?_ ?_))
· conv_rhs => rw [← hinv, mul_comm]
apply mul_le_mul_left' (FractionalIdeal.spanSingleton_le_iff_mem.mpr hw)
· rw [FractionalIdeal.one_le, ← hvw, mul_comm]
exact FractionalIdeal.mul_mem_mul (FractionalIdeal.mem_spanSingleton_self _ _) hv | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | FractionalIdeal.isPrincipal_of_unit_of_comap_mul_span_singleton_eq_top | null |
FractionalIdeal.isPrincipal.of_finite_maximals_of_inv {A : Type*} [CommRing A]
[Algebra R A] {S : Submonoid R} [IsLocalization S A] (hS : S ≤ R⁰)
(hf : {I : Ideal R | I.IsMaximal}.Finite) (I I' : FractionalIdeal S A) (hinv : I * I' = 1) :
Submodule.IsPrincipal (I : Submodule R A) := by
have hinv' := hinv
rw [coe_ext_iff, coe_mul] at hinv
let s := hf.toFinset
haveI := Classical.decEq (Ideal R)
have coprime : ∀ M ∈ s, ∀ M' ∈ s.erase M, M ⊔ M' = ⊤ := by
simp_rw [s, Finset.mem_erase, hf.mem_toFinset]
rintro M hM M' ⟨hne, hM'⟩
exact Ideal.IsMaximal.coprime_of_ne hM hM' hne.symm
have nle : ∀ M ∈ s, ¬⨅ M' ∈ s.erase M, M' ≤ M := fun M hM =>
left_lt_sup.1
((hf.mem_toFinset.1 hM).ne_top.lt_top.trans_eq (Ideal.sup_iInf_eq_top <| coprime M hM).symm)
have : ∀ M ∈ s, ∃ a ∈ I, ∃ b ∈ I', a * b ∉ IsLocalization.coeSubmodule A M := by
intro M hM; by_contra! h
obtain ⟨x, hx, hxM⟩ :=
SetLike.exists_of_lt
((IsLocalization.coeSubmodule_strictMono hS (hf.mem_toFinset.1 hM).ne_top.lt_top).trans_eq
hinv.symm)
exact hxM (Submodule.mul_le.2 h hx)
choose! a ha b hb hm using this
choose! u hu hum using fun M hM => SetLike.not_le_iff_exists.1 (nle M hM)
let v := ∑ M ∈ s, u M • b M
have hv : v ∈ I' := Submodule.sum_mem _ fun M hM => Submodule.smul_mem _ _ <| hb M hM
refine
FractionalIdeal.isPrincipal_of_unit_of_comap_mul_span_singleton_eq_top
(Units.mkOfMulEqOne I I' hinv') hv (of_not_not fun h => ?_)
obtain ⟨M, hM, hJM⟩ := Ideal.exists_le_maximal _ h
replace hM := hf.mem_toFinset.2 hM
have : ∀ a ∈ I, ∀ b ∈ I', ∃ c, algebraMap R _ c = a * b := by
intro a ha b hb; have hi := hinv.le
obtain ⟨c, -, hc⟩ := hi (Submodule.mul_mem_mul ha hb)
exact ⟨c, hc⟩
have hmem : a M * v ∈ IsLocalization.coeSubmodule A M := by
obtain ⟨c, hc⟩ := this _ (ha M hM) v hv
refine IsLocalization.coeSubmodule_mono _ hJM ⟨c, ?_, hc⟩
have := Submodule.mul_mem_mul (ha M hM) (Submodule.mem_span_singleton_self v)
rwa [← hc] at this
simp_rw [v, Finset.mul_sum, mul_smul_comm] at hmem
rw [← s.add_sum_erase _ hM, Submodule.add_mem_iff_left] at hmem
· refine hm M hM ?_
obtain ⟨c, hc : algebraMap R A c = a M * b M⟩ := this _ (ha M hM) _ (hb M hM)
rw [← hc] at hmem ⊢
rw [Algebra.smul_def, ← map_mul] at hmem
obtain ⟨d, hdM, he⟩ := hmem
rw [IsLocalization.injective _ hS he] at hdM
exact Submodule.mem_map_of_mem (f := Algebra.linearMap _ _)
(((hf.mem_toFinset.1 hM).isPrime.mem_or_mem hdM).resolve_left <| hum M hM)
· refine Submodule.sum_mem _ fun M' hM' => ?_
... | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | FractionalIdeal.isPrincipal.of_finite_maximals_of_inv | An invertible fractional ideal of a commutative ring with finitely many maximal ideals is principal.
https://math.stackexchange.com/a/95857 |
Ideal.IsPrincipal.of_finite_maximals_of_isUnit (hf : {I : Ideal R | I.IsMaximal}.Finite)
{I : Ideal R} (hI : IsUnit (I : FractionalIdeal R⁰ (FractionRing R))) : I.IsPrincipal :=
(IsLocalization.coeSubmodule_isPrincipal _ le_rfl).mp
(FractionalIdeal.isPrincipal.of_finite_maximals_of_inv le_rfl hf I
(↑hI.unit⁻¹ : FractionalIdeal R⁰ (FractionRing R)) hI.unit.mul_inv) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | Ideal.IsPrincipal.of_finite_maximals_of_isUnit | An invertible ideal in a commutative ring with finitely many maximal ideals is principal.
https://math.stackexchange.com/a/95857 |
IsPrincipalIdealRing.of_finite_primes [IsDedekindDomain R]
(h : {I : Ideal R | I.IsPrime}.Finite) : IsPrincipalIdealRing R :=
⟨fun I => by
obtain rfl | hI := eq_or_ne I ⊥
· exact bot_isPrincipal
apply Ideal.IsPrincipal.of_finite_maximals_of_isUnit
· apply h.subset; exact @Ideal.IsMaximal.isPrime _ _
· exact isUnit_of_mul_eq_one _ _ (FractionalIdeal.coe_ideal_mul_inv I hI)⟩
variable [IsDedekindDomain R]
variable (S : Type*) [CommRing S]
variable [Algebra R S] [NoZeroSMulDivisors R S] [Module.Finite R S]
variable (p : Ideal R) (hp0 : p ≠ ⊥) [IsPrime p]
variable {Sₚ : Type*} [CommRing Sₚ] [Algebra S Sₚ]
variable [IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ]
variable [Algebra R Sₚ] [IsScalarTower R S Sₚ]
include hp0
/- The first hypothesis below follows from properties of the localization but is needed for the
second, so we leave it to the user to provide (automatically). -/
variable [IsDedekindDomain Sₚ] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | IsPrincipalIdealRing.of_finite_primes | A Dedekind domain is a PID if its set of primes is finite. |
IsLocalization.OverPrime.mem_normalizedFactors_of_isPrime [IsDomain S]
{P : Ideal Sₚ} (hP : IsPrime P) (hP0 : P ≠ ⊥) :
P ∈ normalizedFactors (Ideal.map (algebraMap R Sₚ) p) := by
have non_zero_div : Algebra.algebraMapSubmonoid S p.primeCompl ≤ S⁰ :=
map_le_nonZeroDivisors_of_injective _ (FaithfulSMul.algebraMap_injective _ _)
p.primeCompl_le_nonZeroDivisors
letI : Algebra (Localization.AtPrime p) Sₚ := localizationAlgebra p.primeCompl S
haveI : IsScalarTower R (Localization.AtPrime p) Sₚ :=
IsScalarTower.of_algebraMap_eq fun x => by
rw [IsScalarTower.algebraMap_apply R S]
exact (IsLocalization.map_eq (T := Algebra.algebraMapSubmonoid S (primeCompl p))
(Submonoid.le_comap_map _) x).symm
obtain ⟨pid, p', ⟨hp'0, hp'p⟩, hpu⟩ :=
(IsDiscreteValuationRing.iff_pid_with_one_nonzero_prime (Localization.AtPrime p)).mp
(IsLocalization.AtPrime.isDiscreteValuationRing_of_dedekind_domain R hp0 _)
have : IsLocalRing.maximalIdeal (Localization.AtPrime p) ≠ ⊥ := by
rw [Submodule.ne_bot_iff] at hp0 ⊢
obtain ⟨x, x_mem, x_ne⟩ := hp0
exact
⟨algebraMap _ _ x, (IsLocalization.AtPrime.to_map_mem_maximal_iff _ _ _).mpr x_mem,
IsLocalization.to_map_ne_zero_of_mem_nonZeroDivisors _ p.primeCompl_le_nonZeroDivisors
(mem_nonZeroDivisors_of_ne_zero x_ne)⟩
rw [← Multiset.singleton_le, ← normalize_eq P, ←
normalizedFactors_irreducible (Ideal.prime_of_isPrime hP0 hP).irreducible, ←
dvd_iff_normalizedFactors_le_normalizedFactors hP0, dvd_iff_le,
IsScalarTower.algebraMap_eq R (Localization.AtPrime p) Sₚ, ← Ideal.map_map,
Localization.AtPrime.map_eq_maximalIdeal, Ideal.map_le_iff_le_comap,
hpu (IsLocalRing.maximalIdeal _) ⟨this, _⟩, hpu (comap _ _) ⟨_, _⟩]
· have : Algebra.IsIntegral (Localization.AtPrime p) Sₚ := ⟨isIntegral_localization⟩
exact mt (Ideal.eq_bot_of_comap_eq_bot) hP0
· exact Ideal.comap_isPrime (algebraMap (Localization.AtPrime p) Sₚ) P
· exact (IsLocalRing.maximalIdeal.isMaximal _).isPrime
· rw [Ne, zero_eq_bot, Ideal.map_eq_bot_iff_of_injective]
· assumption
rw [IsScalarTower.algebraMap_eq R S Sₚ]
exact
(IsLocalization.injective Sₚ non_zero_div).comp (FaithfulSMul.algebraMap_injective _ _) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | IsLocalization.OverPrime.mem_normalizedFactors_of_isPrime | If `p` is a prime in the Dedekind domain `R`, `S` an extension of `R` and `Sₚ` the localization
of `S` at `p`, then all primes in `Sₚ` are factors of the image of `p` in `Sₚ`. |
IsDedekindDomain.isPrincipalIdealRing_localization_over_prime [IsDomain S] :
IsPrincipalIdealRing Sₚ := by
letI := Classical.decEq (Ideal Sₚ)
letI := Classical.decPred fun P : Ideal Sₚ => P.IsPrime
refine
IsPrincipalIdealRing.of_finite_primes
(Set.Finite.ofFinset
{P ∈ {⊥} ∪ (normalizedFactors (Ideal.map (algebraMap R Sₚ) p)).toFinset | P.IsPrime}
fun P => ?_)
rw [Finset.mem_filter, Finset.mem_union, Finset.mem_singleton, Set.mem_setOf,
Multiset.mem_toFinset]
exact
and_iff_right_of_imp fun hP =>
or_iff_not_imp_left.mpr (IsLocalization.OverPrime.mem_normalizedFactors_of_isPrime S p hp0 hP) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas"
] | Mathlib/RingTheory/DedekindDomain/PID.lean | IsDedekindDomain.isPrincipalIdealRing_localization_over_prime | Let `p` be a prime in the Dedekind domain `R` and `S` be an integral extension of `R`,
then the localization `Sₚ` of `S` at `p` is a PID. |
group, selmer group, unit group
-/
set_option quotPrecheck false
local notation K "/" n => Kˣ ⧸ (powMonoidHom n : Kˣ →* Kˣ).range | class | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | group | null |
valuationOfNeZeroToFun (x : Kˣ) : Multiplicative ℤ :=
let hx := IsLocalization.sec R⁰ (x : K)
Multiplicative.ofAdd <|
(-(Associates.mk v.asIdeal).count (Associates.mk <| Ideal.span {hx.fst}).factors : ℤ) -
(-(Associates.mk v.asIdeal).count (Associates.mk <| Ideal.span {(hx.snd : R)}).factors : ℤ)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuationOfNeZeroToFun | The multiplicative `v`-adic valuation on `Kˣ`. |
valuationOfNeZeroToFun_eq (x : Kˣ) :
(v.valuationOfNeZeroToFun x : ℤᵐ⁰) = v.valuation K x := by
classical
rw [show v.valuation K x = _ * _ by rfl]
rw [Units.val_inv_eq_inv_val]
change _ = ite _ _ _ * (ite _ _ _)⁻¹
simp_rw [IsLocalization.toLocalizationMap_sec, SubmonoidClass.coe_subtype,
if_neg <| IsLocalization.sec_fst_ne_zero x.ne_zero,
if_neg (nonZeroDivisors.coe_ne_zero _),
valuationOfNeZeroToFun, ofAdd_sub, ofAdd_neg, div_inv_eq_mul, WithZero.coe_mul,
WithZero.coe_inv, inv_inv] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuationOfNeZeroToFun_eq | null |
valuationOfNeZero : Kˣ →* Multiplicative ℤ where
toFun := v.valuationOfNeZeroToFun
map_one' := by rw [← WithZero.coe_inj, valuationOfNeZeroToFun_eq]; exact map_one _
map_mul' _ _ := by
rw [← WithZero.coe_inj, WithZero.coe_mul]
simp only [valuationOfNeZeroToFun_eq]; exact map_mul _ _ _
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuationOfNeZero | The multiplicative `v`-adic valuation on `Kˣ`. |
valuationOfNeZero_eq (x : Kˣ) : (v.valuationOfNeZero x : ℤᵐ⁰) = v.valuation K x :=
valuationOfNeZeroToFun_eq v x
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuationOfNeZero_eq | null |
valuation_of_unit_eq (x : Rˣ) :
v.valuationOfNeZero (Units.map (algebraMap R K : R →* K) x) = 1 := by
rw [← WithZero.coe_inj, valuationOfNeZero_eq, Units.coe_map, eq_iff_le_not_lt]
constructor
· exact v.valuation_le_one x
· obtain ⟨x, _, hx, _⟩ := x
change ¬v.valuation K (algebraMap R K x) < 1
apply_fun v.intValuation at hx
rw [map_one, map_mul] at hx
rw [not_lt, ← hx, ← mul_one <| v.valuation _ _, valuation_of_algebraMap]
gcongr
exact v.intValuation_le_one _ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuation_of_unit_eq | null |
valuationOfNeZeroMod (n : ℕ) : (K/n) →* Multiplicative (ZMod n) :=
(Int.quotientZMultiplesNatEquivZMod n).toMultiplicative.toMonoidHom.comp <|
QuotientGroup.map (powMonoidHom n : Kˣ →* Kˣ).range
(AddSubgroup.toSubgroup (AddSubgroup.zmultiples (n : ℤ)))
v.valuationOfNeZero
(by
rintro _ ⟨x, rfl⟩
exact
⟨v.valuationOfNeZero x, by simp only [powMonoidHom_apply, map_pow, Int.toAdd_pow]; rfl⟩)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuationOfNeZeroMod | The multiplicative `v`-adic valuation on `Kˣ` modulo `n`-th powers. |
valuation_of_unit_mod_eq (n : ℕ) (x : Rˣ) :
v.valuationOfNeZeroMod n (Units.map (algebraMap R K : R →* K) x : K/n) = 1 := by
erw [valuationOfNeZeroMod, MonoidHom.comp_apply, ← QuotientGroup.coe_mk',
QuotientGroup.map_mk' (G := Kˣ) (N := MonoidHom.range (powMonoidHom n)),
valuation_of_unit_eq, QuotientGroup.mk_one, map_one] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuation_of_unit_mod_eq | null |
selmerGroup : Subgroup <| K/n where
carrier := {x : K/n | ∀ (v) (_ : v ∉ S), (v : HeightOneSpectrum R).valuationOfNeZeroMod n x = 1}
one_mem' _ _ := by rw [map_one]
mul_mem' hx hy v hv := by rw [map_mul, hx v hv, hy v hv, one_mul]
inv_mem' hx v hv := by rw [map_inv, hx v hv, inv_one]
local notation K "⟮" S "," n "⟯" => @selmerGroup _ _ _ K _ _ _ S n | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | selmerGroup | The Selmer group `K⟮S, n⟯`. |
monotone (hS : S ≤ S') : K⟮S,n⟯ ≤ K⟮S',n⟯ := fun _ hx v => hx v ∘ mt (@hS v) | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | monotone | null |
valuation : K⟮S,n⟯ →* S → Multiplicative (ZMod n) where
toFun x v := (v : HeightOneSpectrum R).valuationOfNeZeroMod n (x : K/n)
map_one' := funext fun _ => map_one _
map_mul' x y := by simp only [Subgroup.coe_mul, map_mul]; rfl | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuation | The multiplicative `v`-adic valuations on `K⟮S, n⟯` for all `v ∈ S`. |
valuation_ker_eq :
valuation.ker = K⟮(∅ : Set <| HeightOneSpectrum R),n⟯.subgroupOf (K⟮S,n⟯) := by
ext ⟨_, hx⟩
constructor
· intro hx' v _
by_cases hv : v ∈ S
· exact congr_fun hx' ⟨v, hv⟩
· exact hx v hv
· exact fun hx' => funext fun v => hx' v <| Set.notMem_empty v | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | valuation_ker_eq | null |
fromUnit {n : ℕ} : Rˣ →* K⟮(∅ : Set <| HeightOneSpectrum R),n⟯ where
toFun x :=
⟨QuotientGroup.mk <| Units.map (algebraMap R K).toMonoidHom x, fun v _ =>
v.valuation_of_unit_mod_eq n x⟩
map_one' := by simp only [map_one, QuotientGroup.mk_one, Subgroup.mk_eq_one]
map_mul' _ _ := by simp only [RingHom.toMonoidHom_eq_coe, map_mul, QuotientGroup.mk_mul,
MulMemClass.mk_mul_mk] | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | fromUnit | The natural homomorphism from `Rˣ` to `K⟮∅, n⟯`. |
fromUnit_ker [hn : Fact <| 0 < n] :
(@fromUnit R _ _ K _ _ _ n).ker = (powMonoidHom n : Rˣ →* Rˣ).range := by
ext ⟨_, _, _, _⟩
constructor
· intro hx
rcases (QuotientGroup.eq_one_iff _).mp (Subtype.mk.inj hx) with ⟨⟨v, i, vi, iv⟩, hx⟩
have hv : ↑(_ ^ n : Kˣ) = algebraMap R K _ := congr_arg Units.val hx
have hi : ↑(_ ^ n : Kˣ)⁻¹ = algebraMap R K _ := congr_arg Units.inv hx
rw [Units.val_pow_eq_pow_val] at hv
rw [← inv_pow, Units.inv_mk, Units.val_pow_eq_pow_val] at hi
rcases IsIntegrallyClosed.exists_algebraMap_eq_of_isIntegral_pow (R := R) (x := v) hn.out
(hv.symm ▸ isIntegral_algebraMap) with
⟨v', rfl⟩
rcases IsIntegrallyClosed.exists_algebraMap_eq_of_isIntegral_pow (R := R) (x := i) hn.out
(hi.symm ▸ isIntegral_algebraMap) with
⟨i', rfl⟩
rw [← map_mul, map_eq_one_iff _ <| FaithfulSMul.algebraMap_injective R K] at vi
rw [← map_mul, map_eq_one_iff _ <| FaithfulSMul.algebraMap_injective R K] at iv
rw [Units.val_mk, ← map_pow] at hv
exact ⟨⟨v', i', vi, iv⟩, by
simpa only [Units.ext_iff, powMonoidHom_apply, Units.val_pow_eq_pow_val] using
FaithfulSMul.algebraMap_injective R K hv⟩
· rintro ⟨x, hx⟩
rw [← hx]
exact Subtype.mk_eq_mk.mpr <| (QuotientGroup.eq_one_iff _).mpr ⟨Units.map (algebraMap R K) x,
by simp only [powMonoidHom_apply, RingHom.toMonoidHom_eq_coe, map_pow]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | fromUnit_ker | null |
fromUnitLift [Fact <| 0 < n] : (R/n) →* K⟮(∅ : Set <| HeightOneSpectrum R),n⟯ :=
(QuotientGroup.kerLift _).comp
(QuotientGroup.quotientMulEquivOfEq (fromUnit_ker (R := R))).symm.toMonoidHom | def | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | fromUnitLift | The injection induced by the natural homomorphism from `Rˣ` to `K⟮∅, n⟯`. |
fromUnitLift_injective [Fact <| 0 < n] :
Function.Injective <| @fromUnitLift R _ _ K _ _ _ n _ := by
dsimp only [fromUnitLift, MonoidHom.coe_comp, MulEquiv.coe_toMonoidHom]
exact Function.Injective.comp (QuotientGroup.kerLift_injective _) (MulEquiv.injective _) | theorem | RingTheory | [
"Mathlib.Algebra.Group.Equiv.TypeTags",
"Mathlib.Data.ZMod.QuotientGroup",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.Algebra.Group.Int.TypeTags"
] | Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean | fromUnitLift_injective | null |
@[simps!]
integer : Subalgebra R K :=
{
(⨅ (v) (_ : v ∉ S), (v.valuation K).valuationSubring.toSubring).copy
{x : K | ∀ (v) (_ : v ∉ S), v.valuation K x ≤ 1} <|
Set.ext fun _ => by simp [SetLike.mem_coe] with
algebraMap_mem' := fun x v _ => v.valuation_le_one x } | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | integer | The `R`-subalgebra of `S`-integers of `K`. |
integer_eq :
(S.integer K).toSubring =
⨅ (v) (_ : v ∉ S), (v.valuation K).valuationSubring.toSubring :=
SetLike.ext' <| by ext; simp | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | integer_eq | null |
integer_valuation_le_one (x : S.integer K) {v : HeightOneSpectrum R} (hv : v ∉ S) :
v.valuation K x ≤ 1 :=
x.property v hv | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | integer_valuation_le_one | null |
@[simp] integer_univ : (Set.univ : Set (HeightOneSpectrum R)).integer K = ⊤ := by
ext
tauto | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | integer_univ | If `S` is the whole set of places of `K`, then the `S`-integers are the whole of `K`. |
@[simp] integer_empty : (∅ : Set (HeightOneSpectrum R)).integer K = ⊥ := by
ext x
simp only [Set.integer, Set.mem_empty_iff_false, not_false_eq_true, true_implies]
refine ⟨HeightOneSpectrum.mem_integers_of_valuation_le_one K x, ?_⟩
rintro ⟨y, rfl⟩ v
exact v.valuation_le_one y | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | integer_empty | If `S` is the empty set, then the `S`-integers are the minimal `R`-subalgebra of `K` (which is
just `R` itself, via `Algebra.botEquivOfInjective` and `IsFractionRing.injective`). |
@[simps!]
unit : Subgroup Kˣ :=
(⨅ (v) (_ : v ∉ S), (v.valuation K).valuationSubring.unitGroup).copy
{x : Kˣ | ∀ (v) (_ : v ∉ S), (v : HeightOneSpectrum R).valuation K x = 1} <|
Set.ext fun _ => by
simp only [mem_setOf, SetLike.mem_coe, Subgroup.mem_iInf, Valuation.mem_unitGroup_iff] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | unit | The subgroup of `S`-units of `Kˣ`. |
unit_eq :
S.unit K = ⨅ (v) (_ : v ∉ S), (v.valuation K).valuationSubring.unitGroup :=
Subgroup.copy_eq _ _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | unit_eq | null |
unit_valuation_eq_one (x : S.unit K) {v : HeightOneSpectrum R} (hv : v ∉ S) :
v.valuation K (x : Kˣ) = 1 :=
x.property v hv | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | unit_valuation_eq_one | null |
@[simps apply_val_coe symm_apply_coe]
unitEquivUnitsInteger : S.unit K ≃* (S.integer K)ˣ where
toFun x :=
⟨⟨((x : Kˣ) : K), fun v hv => (x.property v hv).le⟩,
⟨((x⁻¹ : Kˣ) : K), fun v hv => (x⁻¹.property v hv).le⟩,
Subtype.ext x.val.val_inv, Subtype.ext x.val.inv_val⟩
invFun x :=
⟨Units.mk0 x fun hx => x.ne_zero (ZeroMemClass.coe_eq_zero.mp hx),
fun v hv =>
eq_one_of_one_le_mul_left (x.val.property v hv) (x.inv.property v hv) <|
Eq.ge <| by
rw [← map_mul, Units.val_mk0, Subtype.mk_eq_mk.mp x.val_inv, map_one]⟩
map_mul' _ _ := by ext; rfl | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.AdicValuation"
] | Mathlib/RingTheory/DedekindDomain/SInteger.lean | unitEquivUnitsInteger | The group of `S`-units is the group of units of the ring of `S`-integers. |
Derivation (R : Type*) (A : Type*) (M : Type*)
[CommSemiring R] [CommSemiring A] [AddCommMonoid M] [Algebra R A] [Module A M] [Module R M]
extends A →ₗ[R] M where
protected map_one_eq_zero' : toLinearMap 1 = 0
protected leibniz' (a b : A) : toLinearMap (a * b) = a • toLinearMap b + b • toLinearMap a | structure | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | Derivation | `D : Derivation R A M` is an `R`-linear map from `A` to `M` that satisfies the `leibniz`
equality. We also require that `D 1 = 0`. See `Derivation.mk'` for a constructor that deduces this
assumption from the Leibniz rule when `M` is cancellative.
TODO: update this when bimodules are defined. |
Simps.apply (D : Derivation R A M) : A → M := D
initialize_simps_projections Derivation (toFun → apply)
attribute [coe] toLinearMap | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | Simps.apply | The `LinearMap` underlying a `Derivation`. -/
add_decl_doc Derivation.toLinearMap
namespace Derivation
section
variable {R : Type*} {A : Type*} {B : Type*} {M : Type*}
variable [CommSemiring R] [CommSemiring A] [CommSemiring B] [AddCommMonoid M]
variable [Algebra R A] [Algebra R B]
variable [Module A M] [Module B M] [Module R M]
variable (D : Derivation R A M) {D1 D2 : Derivation R A M} (r : R) (a b : A)
instance : FunLike (Derivation R A M) A M where
coe D := D.toFun
coe_injective' D1 D2 h := by cases D1; cases D2; congr; exact DFunLike.coe_injective h
instance : AddMonoidHomClass (Derivation R A M) A M where
map_add D := D.toLinearMap.map_add'
map_zero D := D.toLinearMap.map_zero
-- Not a simp lemma because it can be proved via `coeFn_coe` + `toLinearMap_eq_coe`
theorem toFun_eq_coe : D.toFun = ⇑D :=
rfl
/-- See Note [custom simps projection] |
hasCoeToLinearMap : Coe (Derivation R A M) (A →ₗ[R] M) :=
⟨fun D => D.toLinearMap⟩
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | hasCoeToLinearMap | null |
mk_coe (f : A →ₗ[R] M) (h₁ h₂) : ((⟨f, h₁, h₂⟩ : Derivation R A M) : A → M) = f :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | mk_coe | null |
coeFn_coe (f : Derivation R A M) : ⇑(f : A →ₗ[R] M) = f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | coeFn_coe | null |
coe_injective : @Function.Injective (Derivation R A M) (A → M) DFunLike.coe :=
DFunLike.coe_injective
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | coe_injective | null |
ext (H : ∀ a, D1 a = D2 a) : D1 = D2 :=
DFunLike.ext _ _ H | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | ext | null |
congr_fun (h : D1 = D2) (a : A) : D1 a = D2 a :=
DFunLike.congr_fun h a | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | congr_fun | null |
protected map_add : D (a + b) = D a + D b :=
map_add D a b | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_add | null |
protected map_zero : D 0 = 0 :=
map_zero D
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_zero | null |
map_smul : D (r • a) = r • D a :=
D.toLinearMap.map_smul r a
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_smul | null |
leibniz : D (a * b) = a • D b + b • D a :=
D.leibniz' _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | leibniz | null |
map_smul_of_tower {S : Type*} [SMul S A] [SMul S M] [LinearMap.CompatibleSMul A M S R]
(D : Derivation R A M) (r : S) (a : A) : D (r • a) = r • D a :=
D.toLinearMap.map_smul_of_tower r a
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_smul_of_tower | null |
map_one_eq_zero : D 1 = 0 :=
D.map_one_eq_zero'
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_one_eq_zero | null |
map_algebraMap : D (algebraMap R A r) = 0 := by
rw [← mul_one r, RingHom.map_mul, RingHom.map_one, ← smul_def, map_smul, map_one_eq_zero,
smul_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_algebraMap | null |
map_natCast (n : ℕ) : D (n : A) = 0 := by
rw [← nsmul_one, D.map_smul_of_tower n, map_one_eq_zero, smul_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_natCast | null |
leibniz_pow (n : ℕ) : D (a ^ n) = n • a ^ (n - 1) • D a := by
induction n with
| zero => rw [pow_zero, map_one_eq_zero, zero_smul]
| succ n ihn =>
rcases (zero_le n).eq_or_lt with (rfl | hpos)
· simp
· have : a * a ^ (n - 1) = a ^ n := by rw [← pow_succ', Nat.sub_add_cancel hpos]
simp only [pow_succ', leibniz, ihn, smul_comm a n (_ : M), smul_smul a, add_smul, this,
Nat.add_succ_sub_one, add_zero, one_nsmul]
open Polynomial in
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | leibniz_pow | null |
map_aeval (P : R[X]) (x : A) :
D (aeval x P) = aeval x (derivative P) • D x := by
induction P using Polynomial.induction_on
· simp
· simp [add_smul, *]
· simp [mul_smul, ← Nat.cast_smul_eq_nsmul A] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | map_aeval | null |
eqOn_adjoin {s : Set A} (h : Set.EqOn D1 D2 s) : Set.EqOn D1 D2 (adjoin R s) := fun _ hx =>
Algebra.adjoin_induction (hx := hx) h
(fun r => (D1.map_algebraMap r).trans (D2.map_algebraMap r).symm)
(fun x y _ _ hx hy => by simp only [map_add, *]) fun x y _ _ hx hy => by simp only [leibniz, *] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | eqOn_adjoin | null |
ext_of_adjoin_eq_top (s : Set A) (hs : adjoin R s = ⊤) (h : Set.EqOn D1 D2 s) : D1 = D2 :=
ext fun _ => eqOn_adjoin h <| hs.symm ▸ trivial | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | ext_of_adjoin_eq_top | If adjoin of a set is the whole algebra, then any two derivations equal on this set are equal
on the whole algebra. |
@[simp]
coe_zero : ⇑(0 : Derivation R A M) = 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | coe_zero | null |
coe_zero_linearMap : ↑(0 : Derivation R A M) = (0 : A →ₗ[R] M) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | coe_zero_linearMap | null |
zero_apply (a : A) : (0 : Derivation R A M) a = 0 :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative"
] | Mathlib/RingTheory/Derivation/Basic.lean | zero_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.