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 ⌀ |
|---|---|---|---|---|---|---|
isDedekindRing_iff (K : Type*) [CommRing K] [Algebra A K] [IsFractionRing A K] :
IsDedekindRing A ↔
IsNoetherianRing A ∧ DimensionLEOne A ∧
∀ {x : K}, IsIntegral A x → ∃ y, algebraMap A K y = x :=
⟨fun _ => ⟨inferInstance, inferInstance,
fun {_} => (isIntegrallyClosed_iff K).mp inferInstance⟩,
fun ⟨hr, hd, hi⟩ => { hr, hd, (isIntegrallyClosed_iff K).mpr @hi with }⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Polynomial.RationalRoot"
] | Mathlib/RingTheory/DedekindDomain/Basic.lean | isDedekindRing_iff | An integral domain is a Dedekind domain if and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. |
IsDedekindDomain : Prop
extends IsDomain A, IsDedekindRing A
attribute [instance 90] IsDedekindDomain.toIsDomain | class | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Polynomial.RationalRoot"
] | Mathlib/RingTheory/DedekindDomain/Basic.lean | IsDedekindDomain | A Dedekind domain is an integral domain that is Noetherian, integrally closed, and
has Krull dimension at most one.
This is definition 3.2 of [Neukirch1992].
This is exactly `IsDedekindRing` plus the `IsDomain` hypothesis.
The integral closure condition is independent of the choice of field of fractions:
use `isDedekindDomain_iff` to prove `IsDedekindDomain` for a given `fraction_map`.
This is the default implementation, but there are equivalent definitions,
`IsDedekindDomainDvr` and `IsDedekindDomainInv`. |
isDedekindDomain_iff (K : Type*) [CommRing K] [Algebra A K] [IsFractionRing A K] :
IsDedekindDomain A ↔
IsDomain A ∧ IsNoetherianRing A ∧ DimensionLEOne A ∧
∀ {x : K}, IsIntegral A x → ∃ y, algebraMap A K y = x :=
⟨fun _ => ⟨inferInstance, inferInstance, inferInstance,
fun {_} => (isIntegrallyClosed_iff K).mp inferInstance⟩,
fun ⟨hid, hr, hd, hi⟩ => { hid, hr, hd, (isIntegrallyClosed_iff K).mpr @hi with }⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Polynomial.RationalRoot"
] | Mathlib/RingTheory/DedekindDomain/Basic.lean | isDedekindDomain_iff | Make a Dedekind domain from a Dedekind ring given that it is a domain.
`IsDedekindRing` and `IsDedekindDomain` form a cycle in the typeclass hierarchy:
`IsDedekindRing R + IsDomain R` imply `IsDedekindDomain R`, which implies `IsDedekindRing R`.
This should be safe since the start and end point is the literal same expression,
which the tabled typeclass synthesis algorithm can deal with.
-/
instance [IsDomain A] [IsDedekindRing A] : IsDedekindDomain A where
/-- An integral domain is a Dedekind domain iff and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. |
noncomputable
Submodule.traceDual (I : Submodule B L) : Submodule B L where
__ := (traceForm K L).dualSubmodule (I.restrictScalars A)
smul_mem' c x hx a ha := by
rw [traceForm_apply, smul_mul_assoc, mul_comm, ← smul_mul_assoc, mul_comm]
exact hx _ (Submodule.smul_mem _ c ha)
variable {A K}
local notation:max I:max "ᵛ" => Submodule.traceDual A K I | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | Submodule.traceDual | Under the AKLB setting, `Iᵛ := traceDual A K (I : Submodule B L)` is the
`Submodule B L` such that `x ∈ Iᵛ ↔ ∀ y ∈ I, Tr(x, y) ∈ A` |
mem_traceDual {I : Submodule B L} {x} :
x ∈ Iᵛ ↔ ∀ a ∈ I, traceForm K L x a ∈ (algebraMap A K).range :=
forall₂_congr fun _ _ ↦ mem_one | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | mem_traceDual | null |
le_traceDual_iff_map_le_one {I J : Submodule B L} :
I ≤ Jᵛ ↔ ((I * J : Submodule B L).restrictScalars A).map
((trace K L).restrictScalars A) ≤ 1 := by
rw [Submodule.map_le_iff_le_comap, Submodule.restrictScalars_mul, Submodule.mul_le]
simp [SetLike.le_def, mem_traceDual] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_traceDual_iff_map_le_one | null |
le_traceDual_mul_iff {I J J' : Submodule B L} :
I ≤ (J * J')ᵛ ↔ I * J ≤ J'ᵛ := by
simp_rw [le_traceDual_iff_map_le_one, mul_assoc] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_traceDual_mul_iff | null |
le_traceDual {I J : Submodule B L} :
I ≤ Jᵛ ↔ I * J ≤ 1ᵛ := by
rw [← le_traceDual_mul_iff, mul_one] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_traceDual | null |
le_traceDual_comm {I J : Submodule B L} :
I ≤ Jᵛ ↔ J ≤ Iᵛ := by rw [le_traceDual, mul_comm, ← le_traceDual] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_traceDual_comm | null |
le_traceDual_traceDual {I : Submodule B L} :
I ≤ Iᵛᵛ := le_traceDual_comm.mpr le_rfl
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_traceDual_traceDual | null |
restrictScalars_traceDual {I : Submodule B L} :
Iᵛ.restrictScalars A = (Algebra.traceForm K L).dualSubmodule (I.restrictScalars A) := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | restrictScalars_traceDual | null |
traceDual_bot :
(⊥ : Submodule B L)ᵛ = ⊤ := by ext; simp [mem_traceDual, -RingHom.mem_range]
open scoped Classical in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | traceDual_bot | null |
traceDual_top' :
(⊤ : Submodule B L)ᵛ =
if ((LinearMap.range (Algebra.trace K L)).restrictScalars A ≤ 1) then ⊤ else ⊥ := by
classical
split_ifs with h
· rw [_root_.eq_top_iff]
exact fun _ _ _ _ ↦ h ⟨_, rfl⟩
· simp only [SetLike.le_def, restrictScalars_mem, LinearMap.mem_range, mem_one,
forall_exists_index, forall_apply_eq_imp_iff, not_forall, not_exists] at h
obtain ⟨b, hb⟩ := h
simp_rw [eq_bot_iff, SetLike.le_def, mem_bot, mem_traceDual, mem_top, true_implies,
traceForm_apply, RingHom.mem_range]
contrapose! hb with hx'
obtain ⟨c, hc, hc0⟩ := hx'
simpa [hc0] using hc (c⁻¹ * b)
variable [IsDomain A] [IsFractionRing A K] [FiniteDimensional K L] [Algebra.IsSeparable K L] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | traceDual_top' | null |
traceDual_top [Decidable (IsField A)] :
(⊤ : Submodule B L)ᵛ = if IsField A then ⊤ else ⊥ := by
convert traceDual_top'
rw [← IsFractionRing.surjective_iff_isField (R := A) (K := K),
LinearMap.range_eq_top.mpr (Algebra.trace_surjective K L),
← RingHom.range_eq_top, _root_.eq_top_iff]
simp [SetLike.le_def] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | traceDual_top | null |
map_equiv_traceDual [IsDomain A] [IsFractionRing B L] [IsDomain B]
[FaithfulSMul A B] (I : Submodule B (FractionRing B)) :
(traceDual A (FractionRing A) I).map (FractionRing.algEquiv B L) =
traceDual A K (I.map (FractionRing.algEquiv B L)) := by
change Submodule.map (FractionRing.algEquiv B L).toLinearEquiv.toLinearMap _ =
traceDual A K (I.map (FractionRing.algEquiv B L).toLinearEquiv.toLinearMap)
rw [Submodule.map_equiv_eq_comap_symm, Submodule.map_equiv_eq_comap_symm]
ext x
simp only [traceDual, Submodule.mem_comap,
Submodule.mem_mk]
apply (FractionRing.algEquiv B L).forall_congr
simp only [restrictScalars_mem, LinearEquiv.coe_coe, AlgEquiv.coe_symm_toLinearEquiv,
traceForm_apply, mem_one, AlgEquiv.toEquiv_eq_coe, EquivLike.coe_coe, mem_comap,
AlgEquiv.symm_apply_apply]
refine fun {y} ↦ (forall_congr' fun hy ↦ ?_)
rw [Algebra.trace_eq_of_equiv_equiv (FractionRing.algEquiv A K).toRingEquiv
(FractionRing.algEquiv B L).toRingEquiv]
swap
· ext
exact IsFractionRing.algEquiv_commutes (FractionRing.algEquiv A K) (FractionRing.algEquiv B L) _
simp only [AlgEquiv.toRingEquiv_eq_coe, map_mul, AlgEquiv.coe_ringEquiv,
AlgEquiv.apply_symm_apply, ← AlgEquiv.symm_toRingEquiv, AlgEquiv.algebraMap_eq_apply]
variable [IsIntegrallyClosed A] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | map_equiv_traceDual | null |
Submodule.mem_traceDual_iff_isIntegral {I : Submodule B L} {x} :
x ∈ Iᵛ ↔ ∀ a ∈ I, IsIntegral A (traceForm K L x a) :=
forall₂_congr fun _ _ ↦ mem_one.trans IsIntegrallyClosed.isIntegral_iff.symm
variable [FiniteDimensional K L] [IsIntegralClosure B A L] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | Submodule.mem_traceDual_iff_isIntegral | null |
Submodule.one_le_traceDual_one :
(1 : Submodule B L) ≤ 1ᵛ := by
rw [le_traceDual_iff_map_le_one, mul_one, one_eq_range]
rintro _ ⟨x, ⟨x, rfl⟩, rfl⟩
rw [mem_one]
apply IsIntegrallyClosed.isIntegral_iff.mp
apply isIntegral_trace
rw [IsIntegralClosure.isIntegral_iff (A := B)]
exact ⟨_, rfl⟩
variable [Algebra.IsSeparable K L] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | Submodule.one_le_traceDual_one | null |
isIntegral_discr_mul_of_mem_traceDual
(I : Submodule B L) {ι} [DecidableEq ι] [Fintype ι]
{b : Basis ι K L} (hb : ∀ i, IsIntegral A (b i))
{a x : L} (ha : a ∈ I) (hx : x ∈ Iᵛ) :
IsIntegral A ((discr K b) • a * x) := by
have hinv : IsUnit (traceMatrix K b).det := by
simpa [← discr_def] using discr_isUnit_of_basis _ b
have H := mulVec_cramer (traceMatrix K b) fun i => trace K L (x * a * b i)
have : Function.Injective (traceMatrix K b).mulVec := by
rwa [mulVec_injective_iff_isUnit, isUnit_iff_isUnit_det]
rw [← traceMatrix_of_basis_mulVec, ← mulVec_smul, this.eq_iff,
traceMatrix_of_basis_mulVec] at H
rw [← b.equivFun.symm_apply_apply (_ * _), b.equivFun_symm_apply]
apply IsIntegral.sum
intro i _
rw [smul_mul_assoc, b.equivFun.map_smul, discr_def, mul_comm, ← H, Algebra.smul_def]
refine RingHom.IsIntegralElem.mul _ ?_ (hb _)
apply IsIntegral.algebraMap
rw [cramer_apply]
apply IsIntegral.det
intro j k
rw [updateCol_apply]
split
· rw [mul_assoc]
rw [mem_traceDual_iff_isIntegral] at hx
apply hx
have ⟨y, hy⟩ := (IsIntegralClosure.isIntegral_iff (A := B)).mp (hb j)
rw [mul_comm, ← hy, ← Algebra.smul_def]
exact I.smul_mem _ (ha)
· exact isIntegral_trace (RingHom.IsIntegralElem.mul _ (hb j) (hb k))
variable (A K)
variable [IsDomain A] [IsFractionRing B L] [Nontrivial B] [NoZeroDivisors B] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | isIntegral_discr_mul_of_mem_traceDual | If `b` is an `A`-integral basis of `L` with discriminant `b`, then `d • a * x` is integral over
`A` for all `a ∈ I` and `x ∈ Iᵛ`. |
noncomputable
dual (I : FractionalIdeal B⁰ L) :
FractionalIdeal B⁰ L :=
if hI : I = 0 then 0 else
⟨Iᵛ, by
classical
have ⟨s, b, hb⟩ := FiniteDimensional.exists_is_basis_integral A K L
obtain ⟨x, hx, hx'⟩ := exists_ne_zero_mem_isInteger hI
have ⟨y, hy⟩ := (IsIntegralClosure.isIntegral_iff (A := B)).mp
(IsIntegral.algebraMap (B := L) (discr_isIntegral K hb))
refine ⟨y * x, mem_nonZeroDivisors_iff_ne_zero.mpr (mul_ne_zero ?_ hx), fun z hz ↦ ?_⟩
· rw [← (IsIntegralClosure.algebraMap_injective B A L).ne_iff, hy, RingHom.map_zero,
← (algebraMap K L).map_zero, (algebraMap K L).injective.ne_iff]
exact discr_not_zero_of_basis K b
· convert isIntegral_discr_mul_of_mem_traceDual I hb hx' hz using 1
· ext w; exact (IsIntegralClosure.isIntegral_iff (A := B)).symm
· rw [Algebra.smul_def, RingHom.map_mul, hy, ← Algebra.smul_def]⟩ | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual | The dual of a non-zero fractional ideal is the dual of the submodule under the trace form. |
coe_dual (hI : I ≠ 0) :
(dual A K I : Submodule B L) = Iᵛ := by rw [dual, dif_neg hI, coe_mk]
variable (B L)
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | coe_dual | null |
coe_dual_one :
(dual A K (1 : FractionalIdeal B⁰ L) : Submodule B L) = 1ᵛ := by
rw [← coe_one, coe_dual]
exact one_ne_zero
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | coe_dual_one | null |
dual_zero :
dual A K (0 : FractionalIdeal B⁰ L) = 0 := by rw [dual, dif_pos rfl]
variable {A K L B} | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_zero | null |
mem_dual (hI : I ≠ 0) {x} :
x ∈ dual A K I ↔ ∀ a ∈ I, traceForm K L x a ∈ (algebraMap A K).range := by
rw [dual, dif_neg hI]; exact forall₂_congr fun _ _ ↦ mem_one
variable (A K) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | mem_dual | null |
dual_ne_zero (hI : I ≠ 0) :
dual A K I ≠ 0 := by
obtain ⟨b, hb, hb'⟩ := I.prop
suffices algebraMap B L b ∈ dual A K I by
intro e
rw [e, mem_zero_iff, ← (algebraMap B L).map_zero,
(IsIntegralClosure.algebraMap_injective B A L).eq_iff] at this
exact mem_nonZeroDivisors_iff_ne_zero.mp hb this
rw [mem_dual hI]
intro a ha
apply IsIntegrallyClosed.isIntegral_iff.mp
apply isIntegral_trace
dsimp
convert hb' a ha using 1
· ext w
exact IsIntegralClosure.isIntegral_iff (A := B)
· exact (Algebra.smul_def _ _).symm
variable {A K}
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_ne_zero | null |
dual_eq_zero_iff :
dual A K I = 0 ↔ I = 0 :=
⟨not_imp_not.mp (dual_ne_zero A K), fun e ↦ e.symm ▸ dual_zero A K L B⟩ | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_eq_zero_iff | null |
dual_ne_zero_iff :
dual A K I ≠ 0 ↔ I ≠ 0 := dual_eq_zero_iff.not
variable (A K) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_ne_zero_iff | null |
le_dual_inv_aux (hI : I ≠ 0) (hIJ : I * J ≤ 1) :
J ≤ dual A K I := by
rw [dual, dif_neg hI]
intro x hx y hy
rw [mem_one]
apply IsIntegrallyClosed.isIntegral_iff.mp
apply isIntegral_trace
rw [IsIntegralClosure.isIntegral_iff (A := B)]
have ⟨z, _, hz⟩ := hIJ (FractionalIdeal.mul_mem_mul hy hx)
rw [mul_comm] at hz
exact ⟨z, hz⟩ | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_dual_inv_aux | null |
one_le_dual_one :
1 ≤ dual A K (1 : FractionalIdeal B⁰ L) :=
le_dual_inv_aux A K one_ne_zero (by rw [one_mul]) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | one_le_dual_one | null |
le_dual_iff (hJ : J ≠ 0) :
I ≤ dual A K J ↔ I * J ≤ dual A K 1 := by
by_cases hI : I = 0
· simp [hI]
rw [← coe_le_coe, ← coe_le_coe, coe_mul, coe_dual A K hJ, coe_dual_one, le_traceDual]
variable (I) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | le_dual_iff | null |
inv_le_dual :
I⁻¹ ≤ dual A K I := by
classical
exact if hI : I = 0 then by simp [hI] else le_dual_inv_aux A K hI (le_of_eq (mul_inv_cancel₀ hI)) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | inv_le_dual | null |
dual_inv_le :
(dual A K I)⁻¹ ≤ I := by
by_cases hI : I = 0; · simp [hI]
convert mul_right_mono ((dual A K I)⁻¹)
(mul_left_mono I (inv_le_dual A K I)) using 1
· simp only [mul_inv_cancel₀ hI, one_mul]
· simp only [mul_inv_cancel₀ (dual_ne_zero A K (hI := hI)), mul_assoc, mul_one] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_inv_le | null |
dual_eq_mul_inv :
dual A K I = dual A K 1 * I⁻¹ := by
by_cases hI : I = 0; · simp [hI]
apply le_antisymm
· suffices dual A K I * I ≤ dual A K 1 by
convert mul_right_mono I⁻¹ this using 1; simp only [mul_inv_cancel₀ hI, mul_one, mul_assoc]
rw [← le_dual_iff A K hI]
rw [le_dual_iff A K hI, mul_assoc, inv_mul_cancel₀ hI, mul_one]
variable {I} | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_eq_mul_inv | null |
dual_div_dual :
dual A K J / dual A K I = I / J := by
rw [dual_eq_mul_inv A K J, dual_eq_mul_inv A K I, mul_div_mul_comm, div_self, one_mul]
· exact inv_div_inv J I
· simp only [ne_eq, dual_eq_zero_iff, one_ne_zero, not_false_eq_true] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_div_dual | null |
dual_mul_self (hI : I ≠ 0) :
dual A K I * I = dual A K 1 := by
rw [dual_eq_mul_inv, mul_assoc, inv_mul_cancel₀ hI, mul_one] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_mul_self | null |
self_mul_dual (hI : I ≠ 0) :
I * dual A K I = dual A K 1 := by
rw [mul_comm, dual_mul_self A K hI] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | self_mul_dual | null |
dual_inv :
dual A K I⁻¹ = dual A K 1 * I := by rw [dual_eq_mul_inv, inv_inv]
variable (I)
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_inv | null |
dual_dual :
dual A K (dual A K I) = I := by
rw [dual_eq_mul_inv, dual_eq_mul_inv A K (I := I), mul_inv, inv_inv, ← mul_assoc, mul_inv_cancel₀,
one_mul]
rw [dual_ne_zero_iff]
exact one_ne_zero
variable {I}
@[simp] | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_dual | null |
dual_le_dual (hI : I ≠ 0) (hJ : J ≠ 0) :
dual A K I ≤ dual A K J ↔ J ≤ I := by
nth_rewrite 2 [← dual_dual A K I]
rw [le_dual_iff A K hJ, le_dual_iff A K (I := J) (by rwa [dual_ne_zero_iff]), mul_comm]
variable {A K} | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_le_dual | null |
dual_involutive :
Function.Involutive (dual A K : FractionalIdeal B⁰ L → FractionalIdeal B⁰ L) := dual_dual A K | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_involutive | null |
dual_injective :
Function.Injective (dual A K : FractionalIdeal B⁰ L → FractionalIdeal B⁰ L) :=
dual_involutive.injective | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dual_injective | null |
noncomputable differentIdeal : Ideal B :=
(1 / Submodule.traceDual A (FractionRing A) 1 : Submodule B (FractionRing B)).comap
(Algebra.linearMap B (FractionRing B)) | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | differentIdeal | The different ideal of an extension of integral domains `B/A` is the inverse of the dual of `A`
as an ideal of `B`. See `coeIdeal_differentIdeal` and `coeSubmodule_differentIdeal`. |
coeSubmodule_differentIdeal_fractionRing [Algebra.IsIntegral A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)]
[FiniteDimensional (FractionRing A) (FractionRing B)] :
coeSubmodule (FractionRing B) (differentIdeal A B) =
1 / Submodule.traceDual A (FractionRing A) 1 := by
have : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
rw [coeSubmodule, differentIdeal, Submodule.map_comap_eq, inf_eq_right]
have := FractionalIdeal.dual_inv_le (A := A) (K := FractionRing A)
(1 : FractionalIdeal B⁰ (FractionRing B))
have : _ ≤ ((1 : FractionalIdeal B⁰ (FractionRing B)) : Submodule B (FractionRing B)) := this
simp only [← one_div, FractionalIdeal.val_eq_coe] at this
rw [FractionalIdeal.coe_div (FractionalIdeal.dual_ne_zero _ _ _),
FractionalIdeal.coe_dual] at this
· simpa only [FractionalIdeal.coe_one, Submodule.one_eq_range] using this
· exact one_ne_zero
· exact one_ne_zero | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | coeSubmodule_differentIdeal_fractionRing | null |
coeSubmodule_differentIdeal :
coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
Algebra.linearMap B L := by ext; simp
rw [coeSubmodule, ← this]
have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
↑(FractionRing.algEquiv A K).symm.toRingEquiv =
RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L) := by
apply IsLocalization.ringHom_ext A⁰
ext
simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
← IsScalarTower.algebraMap_apply]
rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
have : Algebra.IsSeparable (FractionRing A) (FractionRing B) :=
Algebra.IsSeparable.of_equiv_equiv _ _ H
have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
have : Algebra.IsIntegral A B := IsIntegralClosure.isIntegral_algebra _ L
simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _,
Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
congr 1
refine (map_equiv_traceDual A K _).trans ?_
congr 1
ext
simp
variable (L) | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | coeSubmodule_differentIdeal | null |
coeIdeal_differentIdeal :
↑(differentIdeal A B) = (FractionalIdeal.dual A K (1 : FractionalIdeal B⁰ L))⁻¹ := by
apply FractionalIdeal.coeToSubmodule_injective
simp only [FractionalIdeal.coe_div
(FractionalIdeal.dual_ne_zero _ _ (@one_ne_zero (FractionalIdeal B⁰ L) _ _ _)),
FractionalIdeal.coe_coeIdeal, coeSubmodule_differentIdeal A K, inv_eq_one_div,
FractionalIdeal.coe_dual_one, FractionalIdeal.coe_one]
variable {A K B L} | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | coeIdeal_differentIdeal | null |
differentIdeal_ne_bot [Module.Finite A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] :
differentIdeal A B ≠ ⊥ := by
let K := FractionRing A
let L := FractionRing B
have : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) L :=
IsIntegralClosure.isLocalization _ K _ _
have : FiniteDimensional K L := .of_isLocalization A B A⁰
rw [ne_eq, ← FractionalIdeal.coeIdeal_inj (K := L), coeIdeal_differentIdeal (K := K)]
simp | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | differentIdeal_ne_bot | null |
differentialIdeal_le_fractionalIdeal_iff
{I : FractionalIdeal B⁰ L} (hI : I ≠ 0) :
differentIdeal A B ≤ I ↔ (((I⁻¹ :) : Submodule B L).restrictScalars A).map
((Algebra.trace K L).restrictScalars A) ≤ 1 := by
rw [coeIdeal_differentIdeal A K L B, FractionalIdeal.inv_le_comm (by simp) hI,
← FractionalIdeal.coe_le_coe, FractionalIdeal.coe_dual_one]
refine le_traceDual_iff_map_le_one.trans ?_
simp | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | differentialIdeal_le_fractionalIdeal_iff | null |
differentialIdeal_le_iff {I : Ideal B} (hI : I ≠ ⊥) :
differentIdeal A B ≤ I ↔ (((I⁻¹ : FractionalIdeal B⁰ L) : Submodule B L).restrictScalars A).map
((Algebra.trace K L).restrictScalars A) ≤ 1 :=
(FractionalIdeal.coeIdeal_le_coeIdeal _).symm.trans
(differentialIdeal_le_fractionalIdeal_iff (I := (I : FractionalIdeal B⁰ L)) (by simpa))
variable (A K)
open Pointwise Polynomial in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | differentialIdeal_le_iff | null |
traceForm_dualSubmodule_adjoin
{x : L} (hx : Algebra.adjoin K {x} = ⊤) (hAx : IsIntegral A x) :
(traceForm K L).dualSubmodule (Subalgebra.toSubmodule (Algebra.adjoin A {x})) =
(aeval x (derivative <| minpoly K x) : L)⁻¹ •
(Subalgebra.toSubmodule (Algebra.adjoin A {x})) := by
classical
have hKx : IsIntegral K x := Algebra.IsIntegral.isIntegral x
let pb := (Algebra.adjoin.powerBasis' hKx).map
((Subalgebra.equivOfEq _ _ hx).trans (Subalgebra.topEquiv))
have pbgen : pb.gen = x := by simp [pb]
have hnondeg : (traceForm K L).Nondegenerate := traceForm_nondegenerate K L
have hpb : ⇑(LinearMap.BilinForm.dualBasis (traceForm K L) hnondeg pb.basis) = _ :=
_root_.funext (traceForm_dualBasis_powerBasis_eq pb)
have : (Subalgebra.toSubmodule (Algebra.adjoin A {x})) =
Submodule.span A (Set.range pb.basis) := by
rw [← span_range_natDegree_eq_adjoin (minpoly.monic hAx) (minpoly.aeval _ _)]
congr; ext y
have : natDegree (minpoly A x) = natDegree (minpoly K x) := by
rw [minpoly.isIntegrallyClosed_eq_field_fractions' K hAx, (minpoly.monic hAx).natDegree_map]
simp only [Finset.coe_image, Finset.coe_range, Set.mem_image, Set.mem_Iio, Set.mem_range,
pb.basis_eq_pow, pbgen]
simp only [this]
exact ⟨fun ⟨a, b, c⟩ ↦ ⟨⟨a, b⟩, c⟩, fun ⟨⟨a, b⟩, c⟩ ↦ ⟨a, b, c⟩⟩
clear_value pb
conv_lhs => rw [this]
rw [← span_coeff_minpolyDiv hAx, LinearMap.BilinForm.dualSubmodule_span_of_basis _ hnondeg,
Submodule.smul_span, hpb]
change _ = Submodule.span A (_ '' _)
simp only [← Set.range_comp, smul_eq_mul, div_eq_inv_mul, pbgen,
minpolyDiv_eq_of_isIntegrallyClosed K hAx]
apply le_antisymm <;> rw [Submodule.span_le]
· rintro _ ⟨i, rfl⟩; exact Submodule.subset_span ⟨i, rfl⟩
· rintro _ ⟨i, rfl⟩
by_cases hi : i < pb.dim
· exact Submodule.subset_span ⟨⟨i, hi⟩, rfl⟩
· rw [Function.comp_apply, coeff_eq_zero_of_natDegree_lt, mul_zero]
· exact zero_mem _
rw [← pb.natDegree_minpoly, pbgen, ← natDegree_minpolyDiv_succ hKx,
← Nat.succ_eq_add_one] at hi
exact le_of_not_gt hi | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | traceForm_dualSubmodule_adjoin | null |
conductor_mul_differentIdeal
(x : B) (hx : Algebra.adjoin K {algebraMap B L x} = ⊤) :
(conductor A x) * differentIdeal A B = Ideal.span {aeval x (derivative (minpoly A x))} := by
classical
have hAx : IsIntegral A x := IsIntegralClosure.isIntegral A L x
haveI := IsIntegralClosure.isFractionRing_of_finite_extension A K L B
apply FractionalIdeal.coeIdeal_injective (K := L)
simp only [FractionalIdeal.coeIdeal_mul, FractionalIdeal.coeIdeal_span_singleton]
rw [coeIdeal_differentIdeal A K L B,
mul_inv_eq_iff_eq_mul₀]
swap
· exact FractionalIdeal.dual_ne_zero A K one_ne_zero
apply FractionalIdeal.coeToSubmodule_injective
simp only [FractionalIdeal.coe_coeIdeal, FractionalIdeal.coe_mul,
FractionalIdeal.coe_spanSingleton, Submodule.span_singleton_mul]
ext y
have hne₁ : aeval (algebraMap B L x) (derivative (minpoly K (algebraMap B L x))) ≠ 0 :=
(Algebra.IsSeparable.isSeparable _ _).aeval_derivative_ne_zero (minpoly.aeval _ _)
have : algebraMap B L (aeval x (derivative (minpoly A x))) ≠ 0 := by
rwa [minpoly.isIntegrallyClosed_eq_field_fractions K L hAx, derivative_map,
aeval_map_algebraMap, aeval_algebraMap_apply] at hne₁
rw [Submodule.mem_smul_iff_inv_mul_mem this, FractionalIdeal.mem_coe, FractionalIdeal.mem_dual,
mem_coeSubmodule_conductor]
swap
· exact one_ne_zero
have hne₂ : (aeval (algebraMap B L x) (derivative (minpoly K (algebraMap B L x))))⁻¹ ≠ 0 := by
rwa [ne_eq, inv_eq_zero]
have : IsIntegral A (algebraMap B L x) := IsIntegral.map (IsScalarTower.toAlgHom A B L) hAx
simp_rw [← Subalgebra.mem_toSubmodule, ← Submodule.mul_mem_smul_iff (y := y * _)
(mem_nonZeroDivisors_of_ne_zero hne₂)]
rw [← traceForm_dualSubmodule_adjoin A K hx this]
simp only [LinearMap.BilinForm.mem_dualSubmodule, traceForm_apply, Subalgebra.mem_toSubmodule,
minpoly.isIntegrallyClosed_eq_field_fractions K L hAx,
derivative_map, aeval_map_algebraMap, aeval_algebraMap_apply, mul_assoc,
FractionalIdeal.mem_one_iff, forall_exists_index, forall_apply_eq_imp_iff]
simp_rw [← IsScalarTower.toAlgHom_apply A B L x, ← AlgHom.map_adjoin_singleton]
simp only [Subalgebra.mem_map, IsScalarTower.coe_toAlgHom', Submodule.one_eq_range,
forall_exists_index, and_imp, forall_apply_eq_imp_iff₂, ← map_mul]
exact ⟨fun H b ↦ (mul_one b) ▸ H b 1 (one_mem _), fun H _ _ _ ↦ H _⟩
open Polynomial Pointwise in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | conductor_mul_differentIdeal | null |
aeval_derivative_mem_differentIdeal
(x : B) (hx : Algebra.adjoin K {algebraMap B L x} = ⊤) :
aeval x (derivative (minpoly A x)) ∈ differentIdeal A B := by
refine SetLike.le_def.mp ?_ (Ideal.mem_span_singleton_self _)
rw [← conductor_mul_differentIdeal A K L x hx]
exact Ideal.mul_le_left | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | aeval_derivative_mem_differentIdeal | null |
pow_sub_one_dvd_differentIdeal_aux
{p : Ideal A} [p.IsMaximal] (P : Ideal B) {e : ℕ} (he : e ≠ 0) (hp : p ≠ ⊥)
(hP : P ^ e ∣ p.map (algebraMap A B)) : P ^ (e - 1) ∣ differentIdeal A B := by
obtain ⟨a, ha⟩ := (pow_dvd_pow _ (Nat.sub_le e 1)).trans hP
have hp' := (Ideal.map_eq_bot_iff_of_injective
(FaithfulSMul.algebraMap_injective A B)).not.mpr hp
have habot : a ≠ ⊥ := fun ha' ↦ hp' (by simpa [ha'] using ha)
have hPbot : P ≠ ⊥ := by
rintro rfl; apply hp'
rwa [← Ideal.zero_eq_bot, zero_pow he, zero_dvd_iff, Ideal.zero_eq_bot] at hP
have : p.map (algebraMap A B) ∣ a ^ e := by
obtain ⟨b, hb⟩ := hP
apply_fun (· ^ e : Ideal B → _) at ha
apply_fun (· ^ (e - 1) : Ideal B → _) at hb
simp only [mul_pow, ← pow_mul, mul_comm e] at ha hb
conv_lhs at ha => rw [← Nat.sub_add_cancel (Nat.one_le_iff_ne_zero.mpr he)]
rw [pow_add, hb, mul_assoc, mul_right_inj' (pow_ne_zero _ hPbot), pow_one, mul_comm] at ha
exact ⟨_, ha.symm⟩
suffices ∀ x ∈ a, intTrace A B x ∈ p by
have hP : ((P ^ (e - 1) :)⁻¹ : FractionalIdeal B⁰ L) = a / p.map (algebraMap A B) := by
apply inv_involutive.injective
simp only [inv_inv, ha, FractionalIdeal.coeIdeal_mul, inv_div,
mul_div_assoc]
rw [div_self (by simpa), mul_one]
rw [Ideal.dvd_iff_le, differentialIdeal_le_iff (K := K) (L := L) (pow_ne_zero _ hPbot), hP,
Submodule.map_le_iff_le_comap]
intro x hx
rw [Submodule.restrictScalars_mem, FractionalIdeal.mem_coe,
FractionalIdeal.mem_div_iff_of_nonzero (by simpa using hp')] at hx
rw [Submodule.mem_comap, LinearMap.coe_restrictScalars, ← FractionalIdeal.coe_one,
← div_self (G₀ := FractionalIdeal A⁰ K) (a := p) (by simpa using hp),
FractionalIdeal.mem_coe, FractionalIdeal.mem_div_iff_of_nonzero (by simpa using hp)]
simp only [FractionalIdeal.mem_coeIdeal, forall_exists_index, and_imp,
forall_apply_eq_imp_iff₂] at hx
intro y hy'
obtain ⟨y, hy, rfl : algebraMap A K _ = _⟩ := (FractionalIdeal.mem_coeIdeal _).mp hy'
obtain ⟨z, hz, hz'⟩ := hx _ (Ideal.mem_map_of_mem _ hy)
have : trace K L (algebraMap B L z) ∈ (p : FractionalIdeal A⁰ K) := by
rw [← algebraMap_intTrace (A := A)]
exact ⟨intTrace A B z, this z hz, rfl⟩
rwa [mul_comm, ← smul_eq_mul, ← LinearMap.map_smul, Algebra.smul_def, mul_comm,
← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply A B L, ← hz']
intro x hx
rw [← Ideal.Quotient.eq_zero_iff_mem, ← trace_quotient_eq_of_isDedekindDomain,
← isNilpotent_iff_eq_zero]
refine trace_isNilpotent_of_isNilpotent ⟨e, ?_⟩
rw [← map_pow, Ideal.Quotient.eq_zero_iff_mem]
exact (Ideal.dvd_iff_le.mp this) <| Ideal.pow_mem_pow hx _ | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | pow_sub_one_dvd_differentIdeal_aux | null |
pow_sub_one_dvd_differentIdeal [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
{p : Ideal A} [p.IsMaximal] (P : Ideal B) (e : ℕ) (hp : p ≠ ⊥)
(hP : P ^ e ∣ p.map (algebraMap A B)) : P ^ (e - 1) ∣ differentIdeal A B := by
have : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
have : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
by_cases he : e = 0
· rw [he, pow_zero]; exact one_dvd _
exact pow_sub_one_dvd_differentIdeal_aux A (FractionRing A) (FractionRing B) _ he hp hP | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | pow_sub_one_dvd_differentIdeal | null |
not_dvd_differentIdeal_of_intTrace_not_mem
[Algebra.IsSeparable (FractionRing A) (FractionRing B)]
{p : Ideal A} (P Q : Ideal B) (hP : P * Q = Ideal.map (algebraMap A B) p)
(x : B) (hxQ : x ∈ Q) (hx : Algebra.intTrace A B x ∉ p) :
¬ P ∣ differentIdeal A B := by
by_cases hp : p = ⊥
· subst hp
simp only [Ideal.map_bot, Ideal.mul_eq_bot] at hP
obtain (rfl | rfl) := hP
· rw [← Ideal.zero_eq_bot, zero_dvd_iff]
exact differentIdeal_ne_bot
· obtain rfl := hxQ
simp at hx
letI : Algebra (A ⧸ p) (B ⧸ Q) := Ideal.Quotient.algebraQuotientOfLEComap (by
rw [← Ideal.map_le_iff_le_comap, ← hP]
exact Ideal.mul_le_left)
let K := FractionRing A
let L := FractionRing B
have : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) L :=
IsIntegralClosure.isLocalization _ K _ _
have : FiniteDimensional K L := .of_isLocalization A B A⁰
rw [Ideal.dvd_iff_le]
intro H
replace H := (mul_le_mul_right' H Q).trans_eq hP
replace H := (FractionalIdeal.coeIdeal_le_coeIdeal' _ (P := L) le_rfl).mpr H
rw [FractionalIdeal.coeIdeal_mul, coeIdeal_differentIdeal A K] at H
replace H := mul_le_mul_left' H (FractionalIdeal.dual A K 1)
simp only [ne_eq, FractionalIdeal.dual_eq_zero_iff, one_ne_zero, not_false_eq_true,
mul_inv_cancel_left₀] at H
apply hx
suffices Algebra.trace K L (algebraMap B L x) ∈ (p : FractionalIdeal A⁰ K) by
obtain ⟨y, hy, e⟩ := this
rw [← Algebra.algebraMap_intTrace (A := A), Algebra.linearMap_apply,
(IsLocalization.injective _ le_rfl).eq_iff] at e
exact e ▸ hy
refine FractionalIdeal.mul_induction_on (H ⟨_, hxQ, rfl⟩) ?_ ?_
· rintro x hx _ ⟨y, hy, rfl⟩
induction hy using Submodule.span_induction generalizing x with
| mem y h =>
obtain ⟨y, hy, rfl⟩ := h
obtain ⟨z, hz⟩ :=
(FractionalIdeal.mem_dual (by simp)).mp hx 1 ⟨1, trivial, (algebraMap B L).map_one⟩
simp only [Algebra.traceForm_apply, mul_one] at hz
refine ⟨z * y, Ideal.mul_mem_left _ _ hy, ?_⟩
rw [Algebra.linearMap_apply, Algebra.linearMap_apply, mul_comm x,
← IsScalarTower.algebraMap_apply,
← Algebra.smul_def, LinearMap.map_smul_of_tower, ← hz,
Algebra.smul_def, map_mul, mul_comm]
| zero => simp
| add y z _ _ hy hz =>
simp only [map_add, mul_add]
... | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | not_dvd_differentIdeal_of_intTrace_not_mem | null |
not_dvd_differentIdeal_of_isCoprime_of_isSeparable
[Algebra.IsSeparable (FractionRing A) (FractionRing B)]
{p : Ideal A} [p.IsMaximal] (P Q : Ideal B) [P.IsMaximal] [P.LiesOver p]
(hPQ : IsCoprime P Q) (hP : P * Q = Ideal.map (algebraMap A B) p)
[Algebra.IsSeparable (A ⧸ p) (B ⧸ P)] :
¬ P ∣ differentIdeal A B := by
letI : Algebra (A ⧸ p) (B ⧸ Q) := Ideal.Quotient.algebraQuotientOfLEComap (by
rw [← Ideal.map_le_iff_le_comap, ← hP]
exact Ideal.mul_le_left)
have : IsScalarTower A (A ⧸ p) (B ⧸ Q) := .of_algebraMap_eq' rfl
have : Module.Finite (A ⧸ p) (B ⧸ Q) :=
Module.Finite.of_restrictScalars_finite A (A ⧸ p) (B ⧸ Q)
letI e : (B ⧸ p.map (algebraMap A B)) ≃ₐ[A ⧸ p] ((B ⧸ P) × B ⧸ Q) :=
{ __ := (Ideal.quotEquivOfEq hP.symm).trans (Ideal.quotientMulEquivQuotientProd P Q hPQ),
commutes' := Quotient.ind fun _ ↦ rfl }
obtain ⟨x, hx⟩ : ∃ x, Algebra.trace (A ⧸ p) (B ⧸ P) x ≠ 0 := by
simpa [LinearMap.ext_iff] using Algebra.trace_ne_zero (A ⧸ p) (B ⧸ P)
obtain ⟨y, hy⟩ := Ideal.Quotient.mk_surjective (e.symm (x, 0))
refine not_dvd_differentIdeal_of_intTrace_not_mem A P Q hP y ?_ ?_
· simpa [e, Ideal.Quotient.eq_zero_iff_mem] using congr((e $hy).2)
· rw [← Ideal.Quotient.eq_zero_iff_mem, ← Algebra.trace_quotient_eq_of_isDedekindDomain,
hy, Algebra.trace_eq_of_algEquiv, Algebra.trace_prod_apply]
simpa | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | not_dvd_differentIdeal_of_isCoprime_of_isSeparable | null |
not_dvd_differentIdeal_of_isCoprime
[Algebra.IsSeparable (FractionRing A) (FractionRing B)]
{p : Ideal A} [p.IsMaximal] [Finite (A ⧸ p)] (P Q : Ideal B) [P.IsMaximal]
(hPQ : IsCoprime P Q) (hP : P * Q = Ideal.map (algebraMap A B) p) :
¬ P ∣ differentIdeal A B := by
have : P.LiesOver p := by
constructor
refine ‹p.IsMaximal›.eq_of_le ?_ ?_
· simpa using ‹P.IsMaximal›.ne_top
· rw [← Ideal.map_le_iff_le_comap, ← hP]
exact Ideal.mul_le_right
exact not_dvd_differentIdeal_of_isCoprime_of_isSeparable A P Q hPQ hP | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | not_dvd_differentIdeal_of_isCoprime | null |
dvd_differentIdeal_of_not_isSeparable
[Algebra.IsSeparable (FractionRing A) (FractionRing B)]
{p : Ideal A} [p.IsMaximal] (hp : p ≠ ⊥)
(P : Ideal B) [P.IsMaximal] [P.LiesOver p]
(H : ¬ Algebra.IsSeparable (A ⧸ p) (B ⧸ P)) : P ∣ differentIdeal A B := by
obtain ⟨a, ha⟩ : P ∣ p.map (algebraMap A B) :=
Ideal.dvd_iff_le.mpr (Ideal.map_le_iff_le_comap.mpr Ideal.LiesOver.over.le)
by_cases hPa : P ∣ a
· simpa using pow_sub_one_dvd_differentIdeal A P 2 hp
(by rw [pow_two, ha]; exact mul_dvd_mul_left _ hPa)
let K := FractionRing A
let L := FractionRing B
have : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) L :=
IsIntegralClosure.isLocalization _ K _ _
have : FiniteDimensional K L := .of_isLocalization A B A⁰
have hp' := (Ideal.map_eq_bot_iff_of_injective
(FaithfulSMul.algebraMap_injective A B)).not.mpr hp
have habot : a ≠ ⊥ := fun ha' ↦ hp' (by simpa [ha'] using ha)
have hPbot : P ≠ ⊥ := by
rintro rfl; apply hp'
rwa [Ideal.bot_mul] at ha
suffices ∀ x ∈ a, Algebra.intTrace A B x ∈ p by
have hP : ((P :)⁻¹ : FractionalIdeal B⁰ L) = a / p.map (algebraMap A B) := by
apply inv_involutive.injective
simp only [ha, FractionalIdeal.coeIdeal_mul, inv_div, mul_div_assoc]
rw [div_self (by simpa), mul_one, inv_inv]
rw [Ideal.dvd_iff_le, differentialIdeal_le_iff (K := K) (L := L) hPbot, hP,
Submodule.map_le_iff_le_comap]
intro x hx
rw [Submodule.restrictScalars_mem, FractionalIdeal.mem_coe,
FractionalIdeal.mem_div_iff_of_nonzero (by simpa using hp')] at hx
rw [Submodule.mem_comap, LinearMap.coe_restrictScalars, ← FractionalIdeal.coe_one,
← div_self (G₀ := FractionalIdeal A⁰ K) (a := p) (by simpa using hp),
FractionalIdeal.mem_coe, FractionalIdeal.mem_div_iff_of_nonzero (by simpa using hp)]
simp only [FractionalIdeal.mem_coeIdeal, forall_exists_index, and_imp,
forall_apply_eq_imp_iff₂] at hx
intro y hy'
obtain ⟨y, hy, rfl : algebraMap A K _ = _⟩ := (FractionalIdeal.mem_coeIdeal _).mp hy'
obtain ⟨z, hz, hz'⟩ := hx _ (Ideal.mem_map_of_mem _ hy)
have : Algebra.trace K L (algebraMap B L z) ∈ (p : FractionalIdeal A⁰ K) := by
rw [← Algebra.algebraMap_intTrace (A := A)]
exact ⟨Algebra.intTrace A B z, this z hz, rfl⟩
rwa [mul_comm, ← smul_eq_mul, ← LinearMap.map_smul, Algebra.smul_def, mul_comm,
← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply A B L, ← hz']
intro x hx
rw [← Ideal.Quotient.eq_zero_iff_mem, ← Algebra.trace_quotient_eq_of_isDedekindDomain]
letI : Algebra (A ⧸ p) (B ⧸ a) :=
Ideal.Quotient.algebraQuotientOfLEComap (Ideal.map_le_iff_le_comap.mp
(Ideal.dvd_iff_le.mp ⟨_, ha.trans (mul_comm _ _)⟩))
have : IsScalarTower A (A ⧸ p) (B ⧸ a) := .of_algebraMap_eq' rfl
have : Module.Finite (A ⧸ p) (B ⧸ a) := .of_restrictScalars_finite A _ _
... | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dvd_differentIdeal_of_not_isSeparable | null |
not_dvd_differentIdeal_iff
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B} [P.IsPrime] :
¬ P ∣ differentIdeal A B ↔ Algebra.IsUnramifiedAt A P := by
classical
rcases eq_or_ne P ⊥ with rfl | hPbot
· simp_rw [← Ideal.zero_eq_bot, zero_dvd_iff]
simp only [Submodule.zero_eq_bot, differentIdeal_ne_bot, not_false_eq_true, true_iff]
let K := FractionRing A
let L := FractionRing B
have : FiniteDimensional K L := .of_isLocalization A B A⁰
have : IsLocalization B⁰ (Localization.AtPrime (⊥ : Ideal B)) := by
convert (inferInstanceAs
(IsLocalization (⊥ : Ideal B).primeCompl (Localization.AtPrime (⊥ : Ideal B))))
ext; simp [Ideal.primeCompl]
refine (Algebra.FormallyUnramified.iff_of_equiv (A := L)
((IsLocalization.algEquiv B⁰ _ _).restrictScalars A)).mp ?_
have : Algebra.FormallyUnramified K L := by
rwa [Algebra.FormallyUnramified.iff_isSeparable]
refine .comp A K L
have hp : P.under A ≠ ⊥ := mt Ideal.eq_bot_of_comap_eq_bot hPbot
have hp' := (Ideal.map_eq_bot_iff_of_injective
(FaithfulSMul.algebraMap_injective A B)).not.mpr hp
have := Ideal.IsPrime.isMaximal inferInstance hPbot
constructor
· intro H
· rw [Algebra.isUnramifiedAt_iff_map_eq (p := P.under A)]
constructor
· suffices Algebra.IsSeparable (A ⧸ P.under A) (B ⧸ P) by infer_instance
contrapose! H
exact dvd_differentIdeal_of_not_isSeparable A hp P H
· rw [← Ideal.IsDedekindDomain.ramificationIdx_eq_one_iff hPbot Ideal.map_comap_le]
apply Ideal.ramificationIdx_spec
· simp [Ideal.map_le_iff_le_comap]
· contrapose! H
rw [← pow_one P, show 1 = 2 - 1 by simp]
apply pow_sub_one_dvd_differentIdeal _ _ _ hp
simpa [Ideal.dvd_iff_le] using H
· intro H
obtain ⟨Q, h₁, h₂⟩ := Ideal.eq_prime_pow_mul_coprime hp' P
rw [← Ideal.IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count hp' ‹_› hPbot,
Ideal.ramificationIdx_eq_one_of_isUnramifiedAt hPbot, pow_one] at h₂
obtain ⟨h₃, h₄⟩ := (Algebra.isUnramifiedAt_iff_map_eq (p := P.under A) _ _).mp H
exact not_dvd_differentIdeal_of_isCoprime_of_isSeparable
A P Q (Ideal.isCoprime_iff_sup_eq.mpr h₁) h₂.symm | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | not_dvd_differentIdeal_iff | A prime does not divide the different ideal iff it is unramified. |
dvd_differentIdeal_iff
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B} [P.IsPrime] :
P ∣ differentIdeal A B ↔ ¬ Algebra.IsUnramifiedAt A P :=
iff_not_comm.mp not_dvd_differentIdeal_iff.symm | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Unramified",
"Mathlib.RingTheory.Finiteness.Quotient",
"Mathlib.RingTheory.LocalRing.ResidueField.Instances",
"Mathlib.RingTheory.Trace.Quotient",
"Mathlib.RingTheory.Conductor"
] | Mathlib/RingTheory/DedekindDomain/Different.lean | dvd_differentIdeal_iff | A prime divides the different ideal iff it is ramified. |
IsDedekindDomainDvr : Prop extends IsNoetherian A A where
is_dvr_at_nonzero_prime : ∀ P ≠ (⊥ : Ideal A), ∀ _ : P.IsPrime,
IsDiscreteValuationRing (Localization.AtPrime P) | class | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsDedekindDomainDvr | A Dedekind domain is an integral domain that is Noetherian, and the
localization at every nonzero prime is a discrete valuation ring.
This is equivalent to `IsDedekindDomain`. |
Ring.DimensionLEOne.localization {R : Type*} (Rₘ : Type*) [CommRing R] [IsDomain R]
[CommRing Rₘ] [Algebra R Rₘ] {M : Submonoid R} [IsLocalization M Rₘ] (hM : M ≤ R⁰)
[h : Ring.DimensionLEOne R] : Ring.DimensionLEOne Rₘ := ⟨by
intro p hp0 hpp
refine Ideal.isMaximal_def.mpr ⟨hpp.ne_top, Ideal.maximal_of_no_maximal fun P hpP hPm => ?_⟩
have hpP' : (⟨p, hpp⟩ : { p : Ideal Rₘ // p.IsPrime }) < ⟨P, hPm.isPrime⟩ := hpP
rw [← (IsLocalization.orderIsoOfPrime M Rₘ).lt_iff_lt] at hpP'
haveI : Ideal.IsPrime (Ideal.comap (algebraMap R Rₘ) p) :=
((IsLocalization.orderIsoOfPrime M Rₘ) ⟨p, hpp⟩).2.1
haveI : Ideal.IsPrime (Ideal.comap (algebraMap R Rₘ) P) :=
((IsLocalization.orderIsoOfPrime M Rₘ) ⟨P, hPm.isPrime⟩).2.1
have hlt : Ideal.comap (algebraMap R Rₘ) p < Ideal.comap (algebraMap R Rₘ) P := hpP'
refine h.not_lt_lt ⊥ (Ideal.comap _ _) (Ideal.comap _ _) ⟨?_, hlt⟩
exact IsLocalization.bot_lt_comap_prime _ _ hM _ hp0⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | Ring.DimensionLEOne.localization | Localizing a domain of Krull dimension `≤ 1` gives another ring of Krull dimension `≤ 1`.
Note that the same proof can/should be generalized to preserving any Krull dimension,
once we have a suitable definition. |
IsLocalization.isDedekindDomain [IsDedekindDomain A] {M : Submonoid A} (hM : M ≤ A⁰)
(Aₘ : Type*) [CommRing Aₘ] [IsDomain Aₘ] [Algebra A Aₘ] [IsLocalization M Aₘ] :
IsDedekindDomain Aₘ := by
have h : ∀ y : M, IsUnit (algebraMap A (FractionRing A) y) := by
rintro ⟨y, hy⟩
exact IsUnit.mk0 _ (mt IsFractionRing.to_map_eq_zero_iff.mp (nonZeroDivisors.ne_zero (hM hy)))
letI : Algebra Aₘ (FractionRing A) := RingHom.toAlgebra (IsLocalization.lift h)
haveI : IsScalarTower A Aₘ (FractionRing A) :=
IsScalarTower.of_algebraMap_eq fun x => (IsLocalization.lift_eq h x).symm
haveI : IsFractionRing Aₘ (FractionRing A) :=
IsFractionRing.isFractionRing_of_isDomain_of_isLocalization M _ _
refine (isDedekindDomain_iff _ (FractionRing A)).mpr ⟨?_, ?_, ?_, ?_⟩
· infer_instance
· exact IsLocalization.isNoetherianRing M _ inferInstance
· exact Ring.DimensionLEOne.localization Aₘ hM
· intro x hx
obtain ⟨⟨y, y_mem⟩, hy⟩ := hx.exists_multiple_integral_of_isLocalization M _
obtain ⟨z, hz⟩ := (isIntegrallyClosed_iff _).mp IsDedekindRing.toIsIntegralClosure hy
refine ⟨IsLocalization.mk' Aₘ z ⟨y, y_mem⟩, (IsLocalization.lift_mk'_spec _ _ _ _).mpr ?_⟩
rw [hz, ← Algebra.smul_def]
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsLocalization.isDedekindDomain | The localization of a Dedekind domain is a Dedekind domain. |
IsLocalization.AtPrime.isDedekindDomain [IsDedekindDomain A] (P : Ideal A) [P.IsPrime]
(Aₘ : Type*) [CommRing Aₘ] [IsDomain Aₘ] [Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P] :
IsDedekindDomain Aₘ :=
IsLocalization.isDedekindDomain A P.primeCompl_le_nonZeroDivisors Aₘ | theorem | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsLocalization.AtPrime.isDedekindDomain | The localization of a Dedekind domain at every nonzero prime ideal is a Dedekind domain. |
Localization.AtPrime.isDedekindDomain [IsDedekindDomain A] (P : Ideal A) [P.IsPrime] :
IsDedekindDomain (Localization.AtPrime P) :=
IsLocalization.AtPrime.isDedekindDomain A P _ | instance | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | Localization.AtPrime.isDedekindDomain | null |
IsLocalization.AtPrime.not_isField {P : Ideal A} (hP : P ≠ ⊥) [pP : P.IsPrime] (Aₘ : Type*)
[CommRing Aₘ] [Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P] : ¬ IsField Aₘ := by
intro h
letI := h.toField
obtain ⟨x, x_mem, x_ne⟩ := P.ne_bot_iff.mp hP
exact
(IsLocalRing.maximalIdeal.isMaximal _).ne_top
(Ideal.eq_top_of_isUnit_mem _
((IsLocalization.AtPrime.to_map_mem_maximal_iff Aₘ P _).mpr x_mem)
(isUnit_iff_ne_zero.mpr
((map_ne_zero_iff (algebraMap A Aₘ)
(IsLocalization.injective Aₘ P.primeCompl_le_nonZeroDivisors)).mpr
x_ne))) | theorem | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsLocalization.AtPrime.not_isField | null |
IsLocalization.AtPrime.isDiscreteValuationRing_of_dedekind_domain [IsDedekindDomain A]
{P : Ideal A} (hP : P ≠ ⊥) [pP : P.IsPrime] (Aₘ : Type*) [CommRing Aₘ] [IsDomain Aₘ]
[Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P] : IsDiscreteValuationRing Aₘ := by
classical
letI : IsNoetherianRing Aₘ :=
IsLocalization.isNoetherianRing P.primeCompl _ IsDedekindRing.toIsNoetherian
letI : IsLocalRing Aₘ := IsLocalization.AtPrime.isLocalRing Aₘ P
have hnf := IsLocalization.AtPrime.not_isField A hP Aₘ
exact
((IsDiscreteValuationRing.TFAE Aₘ hnf).out 0 2).mpr
(IsLocalization.AtPrime.isDedekindDomain A P _) | theorem | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsLocalization.AtPrime.isDiscreteValuationRing_of_dedekind_domain | In a Dedekind domain, the localization at every nonzero prime ideal is a DVR. |
IsDedekindDomain.isDedekindDomainDvr [IsDedekindDomain A] : IsDedekindDomainDvr A where
is_dvr_at_nonzero_prime := fun _ hP _ =>
IsLocalization.AtPrime.isDiscreteValuationRing_of_dedekind_domain A hP _ | instance | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsDedekindDomain.isDedekindDomainDvr | Dedekind domains, in the sense of Noetherian integrally closed domains of Krull dimension ≤ 1,
are also Dedekind domains in the sense of Noetherian domains where the localization at every
nonzero prime ideal is a DVR. |
IsDedekindDomainDvr.ring_dimensionLEOne [h : IsDedekindDomainDvr A] :
Ring.DimensionLEOne A where
maximalOfPrime := by
intro p hp hpp
rcases p.exists_le_maximal (Ideal.IsPrime.ne_top hpp) with ⟨q, hq, hpq⟩
let f := (IsLocalization.orderIsoOfPrime q.primeCompl (Localization.AtPrime q)).symm
let P := f ⟨p, hpp, hpq.disjoint_compl_left⟩
let Q := f ⟨q, hq.isPrime, Set.disjoint_left.mpr fun _ a => a⟩
have hinj : Function.Injective (algebraMap A (Localization.AtPrime q)) :=
IsLocalization.injective (Localization.AtPrime q) q.primeCompl_le_nonZeroDivisors
have hp1 : P.1 ≠ ⊥ := fun x => hp ((p.map_eq_bot_iff_of_injective hinj).mp x)
have hq1 : Q.1 ≠ ⊥ :=
fun x => (ne_bot_of_le_ne_bot hp hpq) ((q.map_eq_bot_iff_of_injective hinj).mp x)
rcases (IsDiscreteValuationRing.iff_pid_with_one_nonzero_prime (Localization.AtPrime q)).mp
(h.is_dvr_at_nonzero_prime q (ne_bot_of_le_ne_bot hp hpq) hq.isPrime) with ⟨_, huq⟩
rw [show p = q from Subtype.val_inj.mpr <| f.injective <|
Subtype.val_inj.mp (huq.unique ⟨hp1, P.2⟩ ⟨hq1, Q.2⟩)]
exact hq | instance | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsDedekindDomainDvr.ring_dimensionLEOne | null |
IsDedekindDomainDvr.isIntegrallyClosed [h : IsDedekindDomainDvr A] :
IsIntegrallyClosed A :=
IsIntegrallyClosed.of_localization_maximal <| fun p hp0 hpm ↦
let ⟨_, _⟩ := (IsDiscreteValuationRing.iff_pid_with_one_nonzero_prime
(Localization.AtPrime p)).mp (h.is_dvr_at_nonzero_prime p hp0 hpm.isPrime)
inferInstance | instance | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsDedekindDomainDvr.isIntegrallyClosed | null |
IsDedekindDomainDvr.isDedekindDomain [IsDedekindDomainDvr A] : IsDedekindDomain A where | instance | RingTheory | [
"Mathlib.RingTheory.DiscreteValuationRing.TFAE",
"Mathlib.RingTheory.LocalProperties.IntegrallyClosed"
] | Mathlib/RingTheory/DedekindDomain/Dvr.lean | IsDedekindDomainDvr.isDedekindDomain | If an integral domain is Noetherian, and the localization at every nonzero prime is
a discrete valuation ring, then it is a Dedekind domain. |
IsDedekindDomain.HeightOneSpectrum.maxPowDividing (I : Ideal R) : Ideal R :=
v.asIdeal ^ (Associates.mk v.asIdeal).count (Associates.mk I).factors
open Associates in | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | IsDedekindDomain.HeightOneSpectrum.maxPowDividing | Given a maximal ideal `v` and an ideal `I` of `R`, `maxPowDividing` returns the maximal
power of `v` dividing `I`. |
IsDedekindDomain.HeightOneSpectrum.maxPowDividing_eq_pow_multiset_count
[DecidableEq (Ideal R)] {I : Ideal R} (hI : I ≠ 0) :
maxPowDividing v I =
v.asIdeal ^ Multiset.count v.asIdeal (normalizedFactors I) := by
classical
rw [maxPowDividing, factors_mk _ hI, count_some (irreducible_mk.mpr v.irreducible),
← Multiset.count_map_eq_count' _ _ Subtype.val_injective, map_subtype_coe_factors',
factors_eq_normalizedFactors, ← Multiset.count_map_eq_count' _ _ (mk_injective (M := Ideal R))] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | IsDedekindDomain.HeightOneSpectrum.maxPowDividing_eq_pow_multiset_count | null |
Ideal.finite_factors {I : Ideal R} (hI : I ≠ 0) :
{v : HeightOneSpectrum R | v.asIdeal ∣ I}.Finite := by
rw [← Set.finite_coe_iff, Set.coe_setOf]
haveI h_fin := fintypeSubtypeDvd I hI
refine
Finite.of_injective (fun v => (⟨(v : HeightOneSpectrum R).asIdeal, v.2⟩ : { x // x ∣ I })) ?_
intro v w hvw
exact Subtype.coe_injective (HeightOneSpectrum.ext (by simpa using hvw))
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | Ideal.finite_factors | Only finitely many maximal ideals of `R` divide a given nonzero ideal. |
Associates.finite_factors {I : Ideal R} (hI : I ≠ 0) :
∀ᶠ v : HeightOneSpectrum R in Filter.cofinite,
((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ) = 0 := by
have h_supp : {v : HeightOneSpectrum R | ¬((Associates.mk v.asIdeal).count
(Associates.mk I).factors : ℤ) = 0} = {v : HeightOneSpectrum R | v.asIdeal ∣ I} := by
ext v
simp_rw [Int.natCast_eq_zero]
exact Associates.count_ne_zero_iff_dvd hI v.irreducible
rw [Filter.eventually_cofinite, h_supp]
exact Ideal.finite_factors hI | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | Associates.finite_factors | For every nonzero ideal `I` of `v`, there are finitely many maximal ideals `v` such that the
multiplicity of `v` in the factorization of `I`, denoted `val_v(I)`, is nonzero. |
finite_mulSupport {I : Ideal R} (hI : I ≠ 0) :
(mulSupport fun v : HeightOneSpectrum R => v.maxPowDividing I).Finite :=
haveI h_subset : {v : HeightOneSpectrum R | v.maxPowDividing I ≠ 1} ⊆
{v : HeightOneSpectrum R |
((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ) ≠ 0} := by
intro v hv h_zero
have hv' : v.maxPowDividing I = 1 := by
rw [IsDedekindDomain.HeightOneSpectrum.maxPowDividing, Int.natCast_eq_zero.mp h_zero,
pow_zero _]
exact hv hv'
Finite.subset (Filter.eventually_cofinite.mp (Associates.finite_factors hI)) h_subset
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finite_mulSupport | For every nonzero ideal `I` of `v`, there are finitely many maximal ideals `v` such that
`v^(val_v(I))` is not the unit ideal. |
finite_mulSupport_coe {I : Ideal R} (hI : I ≠ 0) :
(mulSupport fun v : HeightOneSpectrum R => (v.asIdeal : FractionalIdeal R⁰ K) ^
((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ)).Finite := by
rw [mulSupport]
simp_rw [Ne, zpow_natCast, ← FractionalIdeal.coeIdeal_pow, FractionalIdeal.coeIdeal_eq_one]
exact finite_mulSupport hI
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finite_mulSupport_coe | For every nonzero ideal `I` of `v`, there are finitely many maximal ideals `v` such that
`v^(val_v(I))`, regarded as a fractional ideal, is not `(1)`. |
finite_mulSupport_inv {I : Ideal R} (hI : I ≠ 0) :
(mulSupport fun v : HeightOneSpectrum R => (v.asIdeal : FractionalIdeal R⁰ K) ^
(-((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ))).Finite := by
rw [mulSupport]
simp_rw [zpow_neg, Ne, inv_eq_one]
exact finite_mulSupport_coe hI
open scoped Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finite_mulSupport_inv | For every nonzero ideal `I` of `v`, there are finitely many maximal ideals `v` such that
`v^-(val_v(I))` is not the unit ideal. |
finprod_not_dvd (I : Ideal R) (hI : I ≠ 0) :
¬v.asIdeal ^ ((Associates.mk v.asIdeal).count (Associates.mk I).factors + 1) ∣
∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I := by
have hf := finite_mulSupport hI
have h_ne_zero : v.maxPowDividing I ≠ 0 := pow_ne_zero _ v.ne_bot
rw [← mul_finprod_cond_ne v hf, pow_add, pow_one, finprod_cond_ne _ _ hf]
intro h_contr
have hv_prime : Prime v.asIdeal := Ideal.prime_of_isPrime v.ne_bot v.isPrime
obtain ⟨w, hw, hvw'⟩ :=
Prime.exists_mem_finset_dvd hv_prime ((mul_dvd_mul_iff_left h_ne_zero).mp h_contr)
have hw_prime : Prime w.asIdeal := Ideal.prime_of_isPrime w.ne_bot w.isPrime
have hvw := Prime.dvd_of_dvd_pow hv_prime hvw'
rw [Prime.dvd_prime_iff_associated hv_prime hw_prime, associated_iff_eq] at hvw
exact (Finset.mem_erase.mp hw).1 (HeightOneSpectrum.ext hvw.symm) | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_not_dvd | For every nonzero ideal `I` of `v`, `v^(val_v(I) + 1)` does not divide `∏_v v^(val_v(I))`. |
Associates.finprod_ne_zero (I : Ideal R) :
Associates.mk (∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I) ≠ 0 := by
classical
rw [Associates.mk_ne_zero, finprod_def]
split_ifs
· rw [Finset.prod_ne_zero_iff]
intro v _
apply pow_ne_zero _ v.ne_bot
· exact one_ne_zero | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | Associates.finprod_ne_zero | null |
finprod_count (I : Ideal R) (hI : I ≠ 0) : (Associates.mk v.asIdeal).count
(Associates.mk (∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I)).factors =
(Associates.mk v.asIdeal).count (Associates.mk I).factors := by
have h_ne_zero := Associates.finprod_ne_zero I
have hv : Irreducible (Associates.mk v.asIdeal) := v.associates_irreducible
have h_dvd := finprod_mem_dvd v (Ideal.finite_mulSupport hI)
have h_not_dvd := Ideal.finprod_not_dvd v I hI
simp only [IsDedekindDomain.HeightOneSpectrum.maxPowDividing] at h_dvd h_ne_zero h_not_dvd
rw [← Associates.mk_dvd_mk] at h_dvd h_not_dvd
simp only [Associates.dvd_eq_le] at h_dvd h_not_dvd
rw [Associates.mk_pow, Associates.prime_pow_dvd_iff_le h_ne_zero hv] at h_dvd h_not_dvd
rw [not_le] at h_not_dvd
apply Nat.eq_of_le_of_lt_succ h_dvd h_not_dvd | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_count | The multiplicity of `v` in `∏_v v^(val_v(I))` equals `val_v(I)`. |
finprod_heightOneSpectrum_factorization {I : Ideal R} (hI : I ≠ 0) :
∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I = I := by
rw [← associated_iff_eq, ← Associates.mk_eq_mk_iff_associated]
classical
apply Associates.eq_of_eq_counts
· apply Associates.finprod_ne_zero I
· apply Associates.mk_ne_zero.mpr hI
intro v hv
obtain ⟨J, hJv⟩ := Associates.exists_rep v
rw [← hJv, Associates.irreducible_mk] at hv
rw [← hJv]
apply Ideal.finprod_count
⟨J, Ideal.isPrime_of_prime (irreducible_iff_prime.mp hv), Irreducible.ne_zero hv⟩ I 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 | The ideal `I` equals the finprod `∏_v v^(val_v(I))`. |
finprod_heightOneSpectrum_factorization_coe {I : Ideal R} (hI : I ≠ 0) :
(∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^
((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ)) = I := by
conv_rhs => rw [← Ideal.finprod_heightOneSpectrum_factorization hI]
rw [FractionalIdeal.coeIdeal_finprod R⁰ K (le_refl _)]
simp_rw [IsDedekindDomain.HeightOneSpectrum.maxPowDividing, FractionalIdeal.coeIdeal_pow,
zpow_natCast] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_heightOneSpectrum_factorization_coe | The ideal `I` equals the finprod `∏_v v^(val_v(I))`, when both sides are regarded as fractional
ideals of `R`. |
finprod_heightOneSpectrum_factorization {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R}
{J : Ideal R} (haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^
((Associates.mk v.asIdeal).count (Associates.mk J).factors -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors : ℤ) = I := by
have hJ_ne_zero : J ≠ 0 := ideal_factor_ne_zero hI haJ
have hJ := Ideal.finprod_heightOneSpectrum_factorization_coe K hJ_ne_zero
have ha_ne_zero : Ideal.span {a} ≠ 0 := constant_factor_ne_zero hI haJ
have ha := Ideal.finprod_heightOneSpectrum_factorization_coe K ha_ne_zero
rw [haJ, ← div_spanSingleton, div_eq_mul_inv, ← coeIdeal_span_singleton, ← hJ, ← ha,
← finprod_inv_distrib]
simp_rw [← zpow_neg]
rw [← finprod_mul_distrib (Ideal.finite_mulSupport_coe hJ_ne_zero)
(Ideal.finite_mulSupport_inv ha_ne_zero)]
apply finprod_congr
intro v
rw [← zpow_add₀ ((@coeIdeal_ne_zero R _ K _ _ _ _).mpr v.ne_bot), sub_eq_add_neg]
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, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `I` is equal to the product `∏_v v^(val_v(J) - val_v(a))`. |
finprod_heightOneSpectrum_factorization_principal_fraction {n : R} (hn : n ≠ 0) (d : ↥R⁰) :
∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^
((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {n} : Ideal R)).factors -
(Associates.mk v.asIdeal).count (Associates.mk ((Ideal.span {(↑d : R)}) :
Ideal R)).factors : ℤ) = spanSingleton R⁰ (mk' K n d) := by
have hd_ne_zero : (algebraMap R K) (d : R) ≠ 0 :=
map_ne_zero_of_mem_nonZeroDivisors _ (IsFractionRing.injective R K) d.property
have h0 : spanSingleton R⁰ (mk' K n d) ≠ 0 := by
rw [spanSingleton_ne_zero_iff, IsFractionRing.mk'_eq_div, ne_eq, div_eq_zero_iff, not_or]
exact ⟨(map_ne_zero_iff (algebraMap R K) (IsFractionRing.injective R K)).mpr hn, hd_ne_zero⟩
have hI : spanSingleton R⁰ (mk' K n d) =
spanSingleton R⁰ ((algebraMap R K) d)⁻¹ * ↑(Ideal.span {n} : Ideal R) := by
rw [coeIdeal_span_singleton, spanSingleton_mul_spanSingleton]
apply congr_arg
rw [IsFractionRing.mk'_eq_div, div_eq_mul_inv, mul_comm]
exact finprod_heightOneSpectrum_factorization h0 hI
open Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_heightOneSpectrum_factorization_principal_fraction | For a nonzero `k = r/s ∈ K`, the fractional ideal `(k)` is equal to the product
`∏_v v^(val_v(r) - val_v(s))`. |
finprod_heightOneSpectrum_factorization_principal {I : FractionalIdeal R⁰ K} (hI : I ≠ 0)
(k : K) (hk : I = spanSingleton R⁰ k) :
∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^
((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {choose
(mk'_surjective R⁰ k)} : Ideal R)).factors -
(Associates.mk v.asIdeal).count (Associates.mk ((Ideal.span {(↑(choose
(choose_spec (mk'_surjective R⁰ k)) : ↥R⁰) : R)}) : Ideal R)).factors : ℤ) = I := by
set n : R := choose (mk'_surjective R⁰ k)
set d : ↥R⁰ := choose (choose_spec (mk'_surjective R⁰ k))
have hnd : mk' K n d = k := choose_spec (choose_spec (mk'_surjective R⁰ k))
have hn0 : n ≠ 0 := by
by_contra h
rw [← hnd, h, IsFractionRing.mk'_eq_div, map_zero, zero_div, spanSingleton_zero] at hk
exact hI hk
rw [finprod_heightOneSpectrum_factorization_principal_fraction hn0 d, hk, hnd]
variable (K)
open Classical in | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | finprod_heightOneSpectrum_factorization_principal | For a nonzero `k = r/s ∈ K`, the fractional ideal `(k)` is equal to the product
`∏_v v^(val_v(r) - val_v(s))`. |
count (I : FractionalIdeal R⁰ K) : ℤ :=
dite (I = 0) (fun _ : I = 0 => 0) fun _ : ¬I = 0 =>
let a := choose (exists_eq_spanSingleton_mul I)
let J := choose (choose_spec (exists_eq_spanSingleton_mul I))
((Associates.mk v.asIdeal).count (Associates.mk J).factors -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors : ℤ) | def | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count | If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that `I = a⁻¹J`,
then we define `val_v(I)` as `(val_v(J) - val_v(a))`. If `I = 0`, we set `val_v(I) = 0`. |
count_zero : count K v (0 : FractionalIdeal R⁰ K) = 0 := by simp only [count, dif_pos]
open Classical in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_zero | val_v(0) = 0. |
count_ne_zero {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) :
count K v I = ((Associates.mk v.asIdeal).count (Associates.mk
(choose (choose_spec (exists_eq_spanSingleton_mul I)))).factors -
(Associates.mk v.asIdeal).count
(Associates.mk (Ideal.span {choose (exists_eq_spanSingleton_mul I)})).factors : ℤ) := by
simp only [count, dif_neg hI]
open Classical in | lemma | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_ne_zero | null |
count_well_defined {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R}
{J : Ideal R} (h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
count K v I = ((Associates.mk v.asIdeal).count (Associates.mk J).factors -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors : ℤ) := by
set a₁ := choose (exists_eq_spanSingleton_mul I)
set J₁ := choose (choose_spec (exists_eq_spanSingleton_mul I))
have h_a₁J₁ : I = spanSingleton R⁰ ((algebraMap R K) a₁)⁻¹ * ↑J₁ :=
(choose_spec (choose_spec (exists_eq_spanSingleton_mul I))).2
have h_a₁_ne_zero : a₁ ≠ 0 := (choose_spec (choose_spec (exists_eq_spanSingleton_mul I))).1
have h_J₁_ne_zero : J₁ ≠ 0 := ideal_factor_ne_zero hI h_a₁J₁
have h_a_ne_zero : Ideal.span {a} ≠ 0 := constant_factor_ne_zero hI h_aJ
have h_J_ne_zero : J ≠ 0 := ideal_factor_ne_zero hI h_aJ
have h_a₁' : spanSingleton R⁰ ((algebraMap R K) a₁) ≠ 0 := by
rw [ne_eq, spanSingleton_eq_zero_iff, ← (algebraMap R K).map_zero,
Injective.eq_iff (IsLocalization.injective K (le_refl R⁰))]
exact h_a₁_ne_zero
have h_a' : spanSingleton R⁰ ((algebraMap R K) a) ≠ 0 := by
rw [ne_eq, spanSingleton_eq_zero_iff, ← (algebraMap R K).map_zero,
Injective.eq_iff (IsLocalization.injective K (le_refl R⁰))]
rw [ne_eq, Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot] at h_a_ne_zero
exact h_a_ne_zero
have hv : Irreducible (Associates.mk v.asIdeal) := by
exact Associates.irreducible_mk.mpr v.irreducible
rw [h_a₁J₁, ← div_spanSingleton, ← div_spanSingleton, div_eq_div_iff h_a₁' h_a',
← coeIdeal_span_singleton, ← coeIdeal_span_singleton, ← coeIdeal_mul, ← coeIdeal_mul] at h_aJ
rw [count, dif_neg hI, sub_eq_sub_iff_add_eq_add, ← natCast_add, ← natCast_add, natCast_inj,
← Associates.count_mul _ _ hv, ← Associates.count_mul _ _ hv, Associates.mk_mul_mk,
Associates.mk_mul_mk, coeIdeal_injective h_aJ]
· rw [ne_eq, Associates.mk_eq_zero]; exact h_J_ne_zero
· rw [ne_eq, Associates.mk_eq_zero, Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot]
exact h_a₁_ne_zero
· rw [ne_eq, Associates.mk_eq_zero]; exact h_J₁_ne_zero
· rw [ne_eq, Associates.mk_eq_zero]; exact h_a_ne_zero | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_well_defined | `val_v(I)` does not depend on the choice of `a` and `J` used to represent `I`. |
count_mul {I I' : FractionalIdeal R⁰ K} (hI : I ≠ 0) (hI' : I' ≠ 0) :
count K v (I * I') = count K v I + count K v I' := by
classical
have hv : Irreducible (Associates.mk v.asIdeal) := by apply v.associates_irreducible
obtain ⟨a, J, ha, haJ⟩ := exists_eq_spanSingleton_mul I
have ha_ne_zero : Associates.mk (Ideal.span {a} : Ideal R) ≠ 0 := by
rw [ne_eq, Associates.mk_eq_zero, Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot]; exact ha
have hJ_ne_zero : Associates.mk J ≠ 0 := Associates.mk_ne_zero.mpr (ideal_factor_ne_zero hI haJ)
obtain ⟨a', J', ha', haJ'⟩ := exists_eq_spanSingleton_mul I'
have ha'_ne_zero : Associates.mk (Ideal.span {a'} : Ideal R) ≠ 0 := by
rw [ne_eq, Associates.mk_eq_zero, Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot]; exact ha'
have hJ'_ne_zero : Associates.mk J' ≠ 0 :=
Associates.mk_ne_zero.mpr (ideal_factor_ne_zero hI' haJ')
have h_prod : I * I' = spanSingleton R⁰ ((algebraMap R K) (a * a'))⁻¹ * ↑(J * J') := by
rw [haJ, haJ', mul_assoc, mul_comm (J : FractionalIdeal R⁰ K), mul_assoc, ← mul_assoc,
spanSingleton_mul_spanSingleton, coeIdeal_mul, RingHom.map_mul, mul_inv,
mul_comm (J : FractionalIdeal R⁰ K)]
rw [count_well_defined K v hI haJ, count_well_defined K v hI' haJ',
count_well_defined K v (mul_ne_zero hI hI') h_prod, ← Associates.mk_mul_mk,
Associates.count_mul hJ_ne_zero hJ'_ne_zero hv, ← Ideal.span_singleton_mul_span_singleton,
← Associates.mk_mul_mk, Associates.count_mul ha_ne_zero ha'_ne_zero hv]
push_cast
ring | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_mul | For nonzero `I, I'`, `val_v(I*I') = val_v(I) + val_v(I')`. |
count_mul' (I I' : FractionalIdeal R⁰ K) [Decidable (I ≠ 0 ∧ I' ≠ 0)] :
count K v (I * I') = if I ≠ 0 ∧ I' ≠ 0 then count K v I + count K v I' else 0 := by
split_ifs with h
· exact count_mul K v h.1 h.2
· rw [← mul_ne_zero_iff, not_ne_iff] at h
rw [h, count_zero] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_mul' | For nonzero `I, I'`, `val_v(I*I') = val_v(I) + val_v(I')`. If `I` or `I'` is zero, then
`val_v(I*I') = 0`. |
count_one : count K v (1 : FractionalIdeal R⁰ K) = 0 := by
have h1 : (1 : FractionalIdeal R⁰ K) =
spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑(1 : Ideal R) := by
rw [(algebraMap R K).map_one, Ideal.one_eq_top, coeIdeal_top, mul_one, inv_one,
spanSingleton_one]
rw [count_well_defined K v one_ne_zero h1, Ideal.span_singleton_one, Ideal.one_eq_top, sub_self] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_one | val_v(1) = 0. |
count_prod {ι} (s : Finset ι) (I : ι → FractionalIdeal R⁰ K) (hS : ∀ i ∈ s, I i ≠ 0) :
count K v (∏ i ∈ s, I i) = ∑ i ∈ s, count K v (I i) := by
classical
induction s using Finset.induction with
| empty => rw [Finset.prod_empty, Finset.sum_empty, count_one]
| insert i s hi hrec =>
have hS' : ∀ i ∈ s, I i ≠ 0 := fun j hj => hS j (Finset.mem_insert_of_mem hj)
have hS0 : ∏ i ∈ s, I i ≠ 0 := Finset.prod_ne_zero_iff.mpr hS'
have hi0 : I i ≠ 0 := hS i (Finset.mem_insert_self i s)
rw [Finset.prod_insert hi, Finset.sum_insert hi, count_mul K v hi0 hS0, hrec hS'] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_prod | null |
count_pow (n : ℕ) (I : FractionalIdeal R⁰ K) :
count K v (I ^ n) = n * count K v I := by
induction n with
| zero => rw [pow_zero, ofNat_zero, zero_mul, count_one]
| succ n h =>
classical rw [pow_succ, count_mul']
by_cases hI : I = 0
· have h_neg : ¬(I ^ n ≠ 0 ∧ I ≠ 0) := by
rw [not_and', not_not, ne_eq]
intro h
exact absurd hI h
rw [if_neg h_neg, hI, count_zero, mul_zero]
· rw [if_pos (And.intro (pow_ne_zero n hI) hI), h, Nat.cast_add,
Nat.cast_one]
ring | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_pow | For every `n ∈ ℕ` and every ideal `I`, `val_v(I^n) = n*val_v(I)`. |
count_self : count K v (v.asIdeal : FractionalIdeal R⁰ K) = 1 := by
have hv : (v.asIdeal : FractionalIdeal R⁰ K) ≠ 0 := coeIdeal_ne_zero.mpr v.ne_bot
have h_self : (v.asIdeal : FractionalIdeal R⁰ K) =
spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal := by
rw [(algebraMap R K).map_one, inv_one, spanSingleton_one, one_mul]
have hv_irred : Irreducible (Associates.mk v.asIdeal) := by apply v.associates_irreducible
classical rw [count_well_defined K v hv h_self, Associates.count_self hv_irred,
Ideal.span_singleton_one, ← Ideal.one_eq_top, Associates.mk_one, Associates.factors_one,
Associates.count_zero hv_irred, ofNat_zero, sub_zero, ofNat_one] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_self | `val_v(v) = 1`, when `v` is regarded as a fractional ideal. |
count_pow_self (n : ℕ) :
count K v ((v.asIdeal : FractionalIdeal R⁰ K) ^ n) = n := by
rw [count_pow, count_self, mul_one] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_pow_self | `val_v(v^n) = n` for every `n ∈ ℕ`. |
count_neg_zpow (n : ℤ) (I : FractionalIdeal R⁰ K) :
count K v (I ^ (-n)) = - count K v (I ^ n) := by
by_cases hI : I = 0
· by_cases hn : n = 0
· rw [hn, neg_zero, zpow_zero, count_one, neg_zero]
· rw [hI, zero_zpow n hn, zero_zpow (-n) (neg_ne_zero.mpr hn), count_zero, neg_zero]
· rw [eq_neg_iff_add_eq_zero, ← count_mul K v (zpow_ne_zero _ hI) (zpow_ne_zero _ hI),
← zpow_add₀ hI, neg_add_cancel, zpow_zero]
exact count_one K v | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_neg_zpow | `val_v(I⁻ⁿ) = -val_v(Iⁿ)` for every `n ∈ ℤ`. |
count_inv (I : FractionalIdeal R⁰ K) :
count K v (I⁻¹) = - count K v I := by
rw [← zpow_neg_one, count_neg_zpow K v (1 : ℤ) I, zpow_one] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_inv | null |
count_zpow (n : ℤ) (I : FractionalIdeal R⁰ K) :
count K v (I ^ n) = n * count K v I := by
obtain n | n := n
· rw [ofNat_eq_coe, zpow_natCast]
exact count_pow K v n I
· rw [negSucc_eq, count_neg_zpow, ← Int.natCast_succ, zpow_natCast, count_pow]
ring | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_zpow | `val_v(Iⁿ) = n*val_v(I)` for every `n ∈ ℤ`. |
count_zpow_self (n : ℤ) :
count K v ((v.asIdeal : FractionalIdeal R⁰ K) ^ n) = n := by
rw [count_zpow, count_self, mul_one] | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_zpow_self | `val_v(v^n) = n` for every `n ∈ ℤ`. |
count_maximal_coprime {w : HeightOneSpectrum R} (hw : w ≠ v) :
count K v (w.asIdeal : FractionalIdeal R⁰ K) = 0 := by
have hw_fact : (w.asIdeal : FractionalIdeal R⁰ K) =
spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑w.asIdeal := by
rw [(algebraMap R K).map_one, inv_one, spanSingleton_one, one_mul]
have hw_ne_zero : (w.asIdeal : FractionalIdeal R⁰ K) ≠ 0 :=
coeIdeal_ne_zero.mpr w.ne_bot
have hv : Irreducible (Associates.mk v.asIdeal) := by apply v.associates_irreducible
have hw' : Irreducible (Associates.mk w.asIdeal) := by apply w.associates_irreducible
classical
rw [count_well_defined K v hw_ne_zero hw_fact, Ideal.span_singleton_one, ← Ideal.one_eq_top,
Associates.mk_one, Associates.factors_one, Associates.count_zero hv, ofNat_zero, sub_zero,
natCast_eq_zero, ← pow_one (Associates.mk w.asIdeal), Associates.factors_prime_pow hw',
Associates.count_some hv, Multiset.replicate_one, Multiset.count_eq_zero,
Multiset.mem_singleton]
simp only [Subtype.mk.injEq]
rw [Associates.mk_eq_mk_iff_associated, associated_iff_eq, ← HeightOneSpectrum.ext_iff]
exact Ne.symm hw | theorem | RingTheory | [
"Mathlib.NumberTheory.RamificationInertia.Basic",
"Mathlib.Order.Filter.Cofinite"
] | Mathlib/RingTheory/DedekindDomain/Factorization.lean | count_maximal_coprime | If `v ≠ w` are two maximal ideals of `R`, then `val_v(w) = 0`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.