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 ⌀ |
|---|---|---|---|---|---|---|
Ideal.minimalPrimes_map_of_surjective {S : Type*} [CommRing S] {f : R →+* S}
(hf : Function.Surjective f) (I : Ideal R) :
(I.map f).minimalPrimes = Ideal.map f '' (I ⊔ (RingHom.ker f)).minimalPrimes := by
apply Set.image_injective.mpr (Ideal.comap_injective_of_surjective f hf)
rw [← Ideal.comap_minimalPrimes_eq_of_surjective hf, ← Set.image_comp,
Ideal.comap_map_of_surjective f hf, Set.image_congr, Set.image_id, RingHom.ker]
intro x hx
exact (Ideal.comap_map_of_surjective f hf _).trans (sup_eq_left.mpr <| le_sup_right.trans hx.1.2) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.minimalPrimes_map_of_surjective | null |
Ideal.minimalPrimes_eq_comap :
I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I) := by
rw [minimalPrimes, ← Ideal.comap_minimalPrimes_eq_of_surjective Ideal.Quotient.mk_surjective,
← RingHom.ker_eq_comap_bot, Ideal.mk_ker] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.minimalPrimes_eq_comap | null |
IsLocalization.minimalPrimes_map [IsLocalization S A] (J : Ideal R) :
(J.map (algebraMap R A)).minimalPrimes = Ideal.comap (algebraMap R A) ⁻¹' J.minimalPrimes := by
ext p
constructor
· intro hp
haveI := hp.1.1
refine ⟨⟨Ideal.IsPrime.comap _, Ideal.map_le_iff_le_comap.mp hp.1.2⟩, ?_⟩
rintro I hI e
have hI' : Disjoint (S : Set R) I := Set.disjoint_of_subset_right e
((IsLocalization.isPrime_iff_isPrime_disjoint S A _).mp hp.1.1).2
refine (Ideal.comap_mono <|
hp.2 ⟨?_, Ideal.map_mono hI.2⟩ (Ideal.map_le_iff_le_comap.mpr e)).trans_eq ?_
· exact IsLocalization.isPrime_of_isPrime_disjoint S A I hI.1 hI'
· exact IsLocalization.comap_map_of_isPrime_disjoint S A _ hI.1 hI'
· intro hp
refine ⟨⟨?_, Ideal.map_le_iff_le_comap.mpr hp.1.2⟩, ?_⟩
· rw [IsLocalization.isPrime_iff_isPrime_disjoint S A, IsLocalization.disjoint_comap_iff S]
refine ⟨hp.1.1, ?_⟩
rintro rfl
exact hp.1.1.ne_top rfl
· intro I hI e
rw [← IsLocalization.map_comap S A I, ← IsLocalization.map_comap S A p]
haveI := hI.1
exact Ideal.map_mono (hp.2 ⟨Ideal.IsPrime.comap _, Ideal.map_le_iff_le_comap.mp hI.2⟩
(Ideal.comap_mono e)) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | IsLocalization.minimalPrimes_map | null |
IsLocalization.minimalPrimes_comap [IsLocalization S A] (J : Ideal A) :
(J.comap (algebraMap R A)).minimalPrimes = Ideal.comap (algebraMap R A) '' J.minimalPrimes := by
conv_rhs => rw [← map_comap S A J, minimalPrimes_map S]
refine (Set.image_preimage_eq_iff.mpr ?_).symm
exact subset_trans (Ideal.minimalPrimes_comap_subset (algebraMap R A) J) (by simp) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | IsLocalization.minimalPrimes_comap | null |
noncomputable cardQuot (S : Submodule R M) : ℕ :=
AddSubgroup.index S.toAddSubgroup | def | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot | The cardinality of `(M ⧸ S)`, if `(M ⧸ S)` is finite, and `0` otherwise.
This is used to define the absolute ideal norm `Ideal.absNorm`. |
cardQuot_apply (S : Submodule R M) : cardQuot S = Nat.card (M ⧸ S) := by
rfl
variable (R M)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_apply | null |
cardQuot_bot [Infinite M] : cardQuot (⊥ : Submodule R M) = 0 :=
AddSubgroup.index_bot.trans Nat.card_eq_zero_of_infinite
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_bot | null |
cardQuot_top : cardQuot (⊤ : Submodule R M) = 1 :=
AddSubgroup.index_top
variable {R M}
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_top | null |
cardQuot_eq_one_iff {P : Submodule R M} : cardQuot P = 1 ↔ P = ⊤ :=
AddSubgroup.index_eq_one.trans (by simp [SetLike.ext_iff]) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_eq_one_iff | null |
cardQuot_mul_of_coprime
{I J : Ideal S} (coprime : IsCoprime I J) : cardQuot (I * J) = cardQuot I * cardQuot J := by
rw [cardQuot_apply, cardQuot_apply, cardQuot_apply,
Nat.card_congr (Ideal.quotientMulEquivQuotientProd I J coprime).toEquiv,
Nat.card_prod] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_mul_of_coprime | Multiplicity of the ideal norm, for coprime ideals.
This is essentially just a repackaging of the Chinese Remainder Theorem. |
Ideal.mul_add_mem_pow_succ_inj (P : Ideal S) {i : ℕ} (a d d' e e' : S) (a_mem : a ∈ P ^ i)
(e_mem : e ∈ P ^ (i + 1)) (e'_mem : e' ∈ P ^ (i + 1)) (h : d - d' ∈ P) :
a * d + e - (a * d' + e') ∈ P ^ (i + 1) := by
have : a * d - a * d' ∈ P ^ (i + 1) := by
simp only [← mul_sub]
exact Ideal.mul_mem_mul a_mem h
convert Ideal.add_mem _ this (Ideal.sub_mem _ e_mem e'_mem) using 1
ring | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Ideal.mul_add_mem_pow_succ_inj | If the `d` from `Ideal.exists_mul_add_mem_pow_succ` is unique, up to `P`,
then so are the `c`s, up to `P ^ (i + 1)`.
Inspired by [Neukirch], proposition 6.1 |
Ideal.exists_mul_add_mem_pow_succ [IsDedekindDomain S] (hP : P ≠ ⊥)
{i : ℕ} (a c : S) (a_mem : a ∈ P ^ i)
(a_notMem : a ∉ P ^ (i + 1)) (c_mem : c ∈ P ^ i) :
∃ d : S, ∃ e ∈ P ^ (i + 1), a * d + e = c := by
suffices eq_b : P ^ i = Ideal.span {a} ⊔ P ^ (i + 1) by
rw [eq_b] at c_mem
simp only [mul_comm a]
exact Ideal.mem_span_singleton_sup.mp c_mem
refine (Ideal.eq_prime_pow_of_succ_lt_of_le hP (lt_of_le_of_ne le_sup_right ?_)
(sup_le (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr a_mem))
(Ideal.pow_succ_lt_pow hP i).le)).symm
contrapose! a_notMem with this
rw [this]
exact mem_sup.mpr ⟨a, mem_span_singleton_self a, 0, by simp, by simp⟩ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Ideal.exists_mul_add_mem_pow_succ | If `a ∈ P^i \ P^(i+1)` and `c ∈ P^i`, then `a * d + e = c` for `e ∈ P^(i+1)`.
`Ideal.mul_add_mem_pow_succ_unique` shows the choice of `d` is unique, up to `P`.
Inspired by [Neukirch], proposition 6.1 |
Ideal.mem_prime_of_mul_mem_pow [IsDedekindDomain S] {P : Ideal S} [P_prime : P.IsPrime]
(hP : P ≠ ⊥) {i : ℕ} {a b : S} (a_notMem : a ∉ P ^ (i + 1)) (ab_mem : a * b ∈ P ^ (i + 1)) :
b ∈ P := by
simp only [← Ideal.span_singleton_le_iff_mem, ← Ideal.dvd_iff_le, pow_succ, ←
Ideal.span_singleton_mul_span_singleton] at a_notMem ab_mem ⊢
exact (prime_pow_succ_dvd_mul (Ideal.prime_of_isPrime hP P_prime) ab_mem).resolve_left a_notMem | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Ideal.mem_prime_of_mul_mem_pow | null |
Ideal.mul_add_mem_pow_succ_unique [IsDedekindDomain S] (hP : P ≠ ⊥)
{i : ℕ} (a d d' e e' : S)
(a_notMem : a ∉ P ^ (i + 1)) (e_mem : e ∈ P ^ (i + 1)) (e'_mem : e' ∈ P ^ (i + 1))
(h : a * d + e - (a * d' + e') ∈ P ^ (i + 1)) : d - d' ∈ P := by
have h' : a * (d - d') ∈ P ^ (i + 1) := by
convert Ideal.add_mem _ h (Ideal.sub_mem _ e'_mem e_mem) using 1
ring
exact Ideal.mem_prime_of_mul_mem_pow hP a_notMem h' | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Ideal.mul_add_mem_pow_succ_unique | The choice of `d` in `Ideal.exists_mul_add_mem_pow_succ` is unique, up to `P`.
Inspired by [Neukirch], proposition 6.1 |
cardQuot_pow_of_prime [IsDedekindDomain S] (hP : P ≠ ⊥) {i : ℕ} :
cardQuot (P ^ i) = cardQuot P ^ i := by
induction i with
| zero => simp
| succ i ih => ?_
have : P ^ (i + 1) < P ^ i := Ideal.pow_succ_lt_pow hP i
suffices hquot : map (P ^ i.succ).mkQ (P ^ i) ≃ S ⧸ P by
rw [pow_succ' (cardQuot P), ← ih, cardQuot_apply (P ^ i.succ), ←
card_quotient_mul_card_quotient (P ^ i) (P ^ i.succ) this.le, cardQuot_apply (P ^ i),
cardQuot_apply P, Nat.card_congr hquot]
choose a a_mem a_notMem using SetLike.exists_of_lt this
choose f g hg hf using fun c (hc : c ∈ P ^ i) =>
Ideal.exists_mul_add_mem_pow_succ hP a c a_mem a_notMem hc
choose k hk_mem hk_eq using fun c' (hc' : c' ∈ map (mkQ (P ^ i.succ)) (P ^ i)) =>
Submodule.mem_map.mp hc'
refine Equiv.ofBijective (fun c' => Quotient.mk'' (f (k c' c'.prop) (hk_mem c' c'.prop))) ⟨?_, ?_⟩
· rintro ⟨c₁', hc₁'⟩ ⟨c₂', hc₂'⟩ h
rw [Subtype.mk_eq_mk, ← hk_eq _ hc₁', ← hk_eq _ hc₂', mkQ_apply, mkQ_apply,
Submodule.Quotient.eq, ← hf _ (hk_mem _ hc₁'), ← hf _ (hk_mem _ hc₂')]
refine Ideal.mul_add_mem_pow_succ_inj _ _ _ _ _ _ a_mem (hg _ _) (hg _ _) ?_
simpa only [Submodule.Quotient.mk''_eq_mk, Submodule.Quotient.mk''_eq_mk,
Submodule.Quotient.eq] using h
· intro d'
refine Quotient.inductionOn' d' fun d => ?_
have hd' := (mem_map (f := mkQ (P ^ i.succ))).mpr ⟨a * d, Ideal.mul_mem_right d _ a_mem, rfl⟩
refine ⟨⟨_, hd'⟩, ?_⟩
simp only [Submodule.Quotient.mk''_eq_mk, Ideal.Quotient.mk_eq_mk, Ideal.Quotient.eq]
refine
Ideal.mul_add_mem_pow_succ_unique hP a _ _ _ _ a_notMem (hg _ (hk_mem _ hd')) (zero_mem _) ?_
rw [hf, add_zero]
exact (Submodule.Quotient.eq _).mp (hk_eq _ hd') | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_pow_of_prime | Multiplicity of the ideal norm, for powers of prime ideals. |
cardQuot_mul [IsDedekindDomain S] [Module.Free ℤ S] (I J : Ideal S) :
cardQuot (I * J) = cardQuot I * cardQuot J := by
let b := Module.Free.chooseBasis ℤ S
haveI : Infinite S := Infinite.of_surjective _ b.repr.toEquiv.surjective
exact UniqueFactorizationMonoid.multiplicative_of_coprime cardQuot I J (cardQuot_bot _ _)
(fun {I J} hI => by simp [Ideal.isUnit_iff.mp hI, Ideal.mul_top])
(fun {I} i hI =>
have : Ideal.IsPrime I := Ideal.isPrime_of_prime hI
cardQuot_pow_of_prime hI.ne_zero)
fun {I J} hIJ => cardQuot_mul_of_coprime <| Ideal.isCoprime_iff_sup_eq.mpr
(Ideal.isUnit_iff.mp
(hIJ (Ideal.dvd_iff_le.mpr le_sup_left) (Ideal.dvd_iff_le.mpr le_sup_right))) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | cardQuot_mul | Multiplicativity of the ideal norm in number rings. |
noncomputable Ideal.absNorm [Nontrivial S] [IsDedekindDomain S] [Module.Free ℤ S] :
Ideal S →*₀ ℕ where
toFun := Submodule.cardQuot
map_mul' I J := by rw [cardQuot_mul]
map_one' := by rw [Ideal.one_eq_top, cardQuot_top]
map_zero' := by
have : Infinite S := Module.Free.infinite ℤ S
rw [Ideal.zero_eq_bot, cardQuot_bot] | def | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Ideal.absNorm | The absolute norm of the ideal `I : Ideal R` is the cardinality of the quotient `R ⧸ I`. |
absNorm_apply (I : Ideal S) : absNorm I = cardQuot I := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_apply | null |
absNorm_bot : absNorm (⊥ : Ideal S) = 0 := by rw [← Ideal.zero_eq_bot, map_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_bot | null |
absNorm_top : absNorm (⊤ : Ideal S) = 1 := by rw [← Ideal.one_eq_top, map_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_top | null |
absNorm_eq_one_iff {I : Ideal S} : absNorm I = 1 ↔ I = ⊤ := by
rw [absNorm_apply, cardQuot_eq_one_iff] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_eq_one_iff | null |
absNorm_ne_zero_iff (I : Ideal S) : Ideal.absNorm I ≠ 0 ↔ Finite (S ⧸ I) :=
⟨fun h => Nat.finite_of_card_ne_zero h, fun h =>
(@AddSubgroup.finiteIndex_of_finite_quotient _ _ _ h).index_ne_zero⟩ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_ne_zero_iff | null |
absNorm_dvd_absNorm_of_le {I J : Ideal S} (h : J ≤ I) : Ideal.absNorm I ∣ Ideal.absNorm J :=
map_dvd absNorm (dvd_iff_le.mpr h) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_dvd_absNorm_of_le | null |
irreducible_of_irreducible_absNorm {I : Ideal S} (hI : Irreducible (Ideal.absNorm I)) :
Irreducible I :=
irreducible_iff.mpr
⟨fun h =>
hI.not_isUnit (by simpa only [Ideal.isUnit_iff, Nat.isUnit_iff, absNorm_eq_one_iff] using h),
by
rintro a b rfl
simpa only [Ideal.isUnit_iff, Nat.isUnit_iff, absNorm_eq_one_iff] using
hI.isUnit_or_isUnit (map_mul absNorm a b)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | irreducible_of_irreducible_absNorm | null |
isPrime_of_irreducible_absNorm {I : Ideal S} (hI : Irreducible (Ideal.absNorm I)) :
I.IsPrime :=
isPrime_of_prime
(UniqueFactorizationMonoid.irreducible_iff_prime.mp (irreducible_of_irreducible_absNorm hI)) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | isPrime_of_irreducible_absNorm | null |
prime_of_irreducible_absNorm_span {a : S} (ha : a ≠ 0)
(hI : Irreducible (Ideal.absNorm (Ideal.span ({a} : Set S)))) : Prime a :=
(Ideal.span_singleton_prime ha).mp (isPrime_of_irreducible_absNorm hI) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | prime_of_irreducible_absNorm_span | null |
absNorm_mem (I : Ideal S) : ↑(Ideal.absNorm I) ∈ I := by
rw [absNorm_apply, cardQuot, ← Ideal.Quotient.eq_zero_iff_mem, map_natCast,
Quotient.index_eq_zero] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_mem | null |
span_singleton_absNorm_le (I : Ideal S) : Ideal.span {(Ideal.absNorm I : S)} ≤ I := by
simp only [Ideal.span_le, Set.singleton_subset_iff, SetLike.mem_coe, Ideal.absNorm_mem I] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | span_singleton_absNorm_le | null |
span_singleton_absNorm {I : Ideal S} (hI : (Ideal.absNorm I).Prime) :
Ideal.span (singleton (Ideal.absNorm I : ℤ)) = I.comap (algebraMap ℤ S) := by
have : Ideal.IsPrime (Ideal.span (singleton (Ideal.absNorm I : ℤ))) := by
rwa [Ideal.span_singleton_prime (Int.ofNat_ne_zero.mpr hI.ne_zero), ← Nat.prime_iff_prime_int]
apply (this.isMaximal _).eq_of_le
· exact ((isPrime_of_irreducible_absNorm
((Nat.irreducible_iff_nat_prime _).mpr hI)).comap (algebraMap ℤ S)).ne_top
· rw [span_singleton_le_iff_mem, mem_comap, algebraMap_int_eq, map_natCast]
exact absNorm_mem I
· rw [Ne, span_singleton_eq_bot]
exact Int.ofNat_ne_zero.mpr hI.ne_zero
variable [Module.Finite ℤ S] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | span_singleton_absNorm | null |
natAbs_det_equiv (I : Ideal S) {E : Type*} [EquivLike E S I] [AddEquivClass E S I] (e : E) :
Int.natAbs
(LinearMap.det
((Submodule.subtype I).restrictScalars ℤ ∘ₗ AddMonoidHom.toIntLinearMap (e : S →+ I))) =
Ideal.absNorm I := by
by_cases hI : I = ⊥
· subst hI
have : (1 : S) ≠ 0 := one_ne_zero
have : (1 : S) = 0 := EquivLike.injective e (Subsingleton.elim _ _)
contradiction
exact Submodule.natAbs_det_equiv (I.restrictScalars ℤ) e | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | natAbs_det_equiv | Let `e : S ≃ I` be an additive isomorphism (therefore a `ℤ`-linear equiv).
Then an alternative way to compute the norm of `I` is given by taking the determinant of `e`.
See `natAbs_det_basis_change` for a more familiar formulation of this result. |
natAbs_det_basis_change {ι : Type*} [Fintype ι] [DecidableEq ι] (b : Basis ι ℤ S)
(I : Ideal S) (bI : Basis ι ℤ I) : (b.det ((↑) ∘ bI)).natAbs = Ideal.absNorm I :=
Submodule.natAbs_det_basis_change b (I.restrictScalars ℤ) bI
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | natAbs_det_basis_change | Let `b` be a basis for `S` over `ℤ` and `bI` a basis for `I` over `ℤ` of the same dimension.
Then an alternative way to compute the norm of `I` is given by taking the determinant of `bI`
over `b`. |
absNorm_span_singleton (r : S) :
absNorm (span ({r} : Set S)) = (Algebra.norm ℤ r).natAbs := by
rw [Algebra.norm_apply]
by_cases hr : r = 0
· simp only [hr, Ideal.span_zero, Ideal.absNorm_bot,
LinearMap.det_zero'', Set.singleton_zero, map_zero, Int.natAbs_zero]
letI := Ideal.finiteQuotientOfFreeOfNeBot (span {r}) (mt span_singleton_eq_bot.mp hr)
let b := Module.Free.chooseBasis ℤ S
rw [← natAbs_det_equiv _ (b.equiv (basisSpanSingleton b hr) (Equiv.refl _))]
congr
refine b.ext fun i => ?_
simp | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_span_singleton | null |
absNorm_dvd_norm_of_mem {I : Ideal S} {x : S} (h : x ∈ I) :
↑(Ideal.absNorm I) ∣ Algebra.norm ℤ x := by
rw [← Int.dvd_natAbs, ← absNorm_span_singleton x, Int.natCast_dvd_natCast]
exact absNorm_dvd_absNorm_of_le ((span_singleton_le_iff_mem _).mpr h)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_dvd_norm_of_mem | null |
absNorm_span_insert (r : S) (s : Set S) :
absNorm (span (insert r s)) ∣ gcd (absNorm (span s)) (Algebra.norm ℤ r).natAbs :=
(dvd_gcd_iff _ _ _).mpr
⟨absNorm_dvd_absNorm_of_le (span_mono (Set.subset_insert _ _)),
_root_.trans
(absNorm_dvd_absNorm_of_le (span_mono (Set.singleton_subset_iff.mpr (Set.mem_insert _ _))))
(by rw [absNorm_span_singleton])⟩ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_span_insert | null |
absNorm_eq_zero_iff {I : Ideal S} : Ideal.absNorm I = 0 ↔ I = ⊥ := by
constructor
· intro hI
rw [← le_bot_iff]
intro x hx
rw [mem_bot, ← Algebra.norm_eq_zero_iff (R := ℤ), ← Int.natAbs_eq_zero,
← Ideal.absNorm_span_singleton, ← zero_dvd_iff, ← hI]
apply Ideal.absNorm_dvd_absNorm_of_le
rwa [Ideal.span_singleton_le_iff_mem]
· rintro rfl
exact absNorm_bot | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_eq_zero_iff | null |
absNorm_ne_zero_iff_mem_nonZeroDivisors {I : Ideal S} :
absNorm I ≠ 0 ↔ I ∈ (Ideal S)⁰ := by
simp_rw [ne_eq, Ideal.absNorm_eq_zero_iff, mem_nonZeroDivisors_iff_ne_zero, Submodule.zero_eq_bot] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_ne_zero_iff_mem_nonZeroDivisors | null |
absNorm_pos_iff_mem_nonZeroDivisors {I : Ideal S} :
0 < absNorm I ↔ I ∈ (Ideal S)⁰ := by
rw [← absNorm_ne_zero_iff_mem_nonZeroDivisors, Nat.pos_iff_ne_zero] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_pos_iff_mem_nonZeroDivisors | null |
absNorm_ne_zero_of_nonZeroDivisors (I : (Ideal S)⁰) : absNorm (I : Ideal S) ≠ 0 :=
absNorm_ne_zero_iff_mem_nonZeroDivisors.mpr (SetLike.coe_mem I) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_ne_zero_of_nonZeroDivisors | null |
absNorm_pos_of_nonZeroDivisors (I : (Ideal S)⁰) : 0 < absNorm (I : Ideal S) :=
absNorm_pos_iff_mem_nonZeroDivisors.mpr (SetLike.coe_mem I) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | absNorm_pos_of_nonZeroDivisors | null |
finite_setOf_absNorm_eq [CharZero S] (n : ℕ) :
{I : Ideal S | Ideal.absNorm I = n}.Finite := by
obtain hn | hn := Nat.eq_zero_or_pos n
· simp only [hn, absNorm_eq_zero_iff, Set.setOf_eq_eq_singleton, Set.finite_singleton]
· let f := fun I : Ideal S => Ideal.map (Ideal.Quotient.mk (@Ideal.span S _ {↑n})) I
refine Set.Finite.of_finite_image (f := f) ?_ ?_
· suffices Finite (S ⧸ @Ideal.span S _ {↑n}) by
let g := ((↑) : Ideal (S ⧸ @Ideal.span S _ {↑n}) → Set (S ⧸ @Ideal.span S _ {↑n}))
refine Set.Finite.of_finite_image (f := g) ?_ SetLike.coe_injective.injOn
exact Set.Finite.subset Set.finite_univ (Set.subset_univ _)
rw [← absNorm_ne_zero_iff, absNorm_span_singleton]
simpa only [Ne, Int.natAbs_eq_zero, Algebra.norm_eq_zero_iff, Nat.cast_eq_zero] using
ne_of_gt hn
· intro I hI J hJ h
rw [← comap_map_mk (span_singleton_absNorm_le I), ← hI.symm, ←
comap_map_mk (span_singleton_absNorm_le J), ← hJ.symm]
congr | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | finite_setOf_absNorm_eq | null |
finite_setOf_absNorm_le [CharZero S] (n : ℕ) :
{I : Ideal S | Ideal.absNorm I ≤ n}.Finite := by
rw [show {I : Ideal S | Ideal.absNorm I ≤ n} =
(⋃ i ∈ Set.Icc 0 n, {I : Ideal S | Ideal.absNorm I = i}) by ext; simp]
refine Set.Finite.biUnion (Set.finite_Icc 0 n) (fun i _ => Ideal.finite_setOf_absNorm_eq i) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | finite_setOf_absNorm_le | null |
finite_setOf_absNorm_le₀ [CharZero S] (n : ℕ) :
{I : (Ideal S)⁰ | Ideal.absNorm (I : Ideal S) ≤ n}.Finite := by
have : Finite {I : Ideal S // I ∈ (Ideal S)⁰ ∧ absNorm I ≤ n} :=
(finite_setOf_absNorm_le n).subset fun _ ⟨_, h⟩ ↦ h
exact Finite.of_equiv _ (Equiv.subtypeSubtypeEquivSubtypeInter _ (fun I ↦ absNorm I ≤ n)).symm | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | finite_setOf_absNorm_le₀ | null |
card_norm_le_eq_card_norm_le_add_one (n : ℕ) [CharZero S] :
Nat.card {I : Ideal S // absNorm I ≤ n} =
Nat.card {I : (Ideal S)⁰ // absNorm (I : Ideal S) ≤ n} + 1 := by
classical
have : Finite {I : Ideal S // I ∈ (Ideal S)⁰ ∧ absNorm I ≤ n} :=
(finite_setOf_absNorm_le n).subset fun _ ⟨_, h⟩ ↦ h
have : Finite {I : Ideal S // I ∉ (Ideal S)⁰ ∧ absNorm I ≤ n} :=
(finite_setOf_absNorm_le n).subset fun _ ⟨_, h⟩ ↦ h
rw [Nat.card_congr (Equiv.subtypeSubtypeEquivSubtypeInter (fun I ↦ I ∈ (Ideal S)⁰)
(fun I ↦ absNorm I ≤ n))]
let e : {I : Ideal S // absNorm I ≤ n} ≃ {I : Ideal S // I ∈ (Ideal S)⁰ ∧ absNorm I ≤ n} ⊕
{I : Ideal S // I ∉ (Ideal S)⁰ ∧ absNorm I ≤ n} := by
refine (Equiv.subtypeEquivRight ?_).trans (subtypeOrEquiv _ _ ?_)
· intro _
simp_rw [← or_and_right, em, true_and]
· exact Pi.disjoint_iff.mpr fun I ↦ Prop.disjoint_iff.mpr (by tauto)
simp_rw [Nat.card_congr e, Nat.card_sum, add_right_inj]
conv_lhs =>
enter [1, 1, I]
rw [← absNorm_ne_zero_iff_mem_nonZeroDivisors, ne_eq, not_not, and_iff_left_iff_imp.mpr
(fun h ↦ by rw [h]; exact Nat.zero_le n), absNorm_eq_zero_iff]
rw [Nat.card_unique] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | card_norm_le_eq_card_norm_le_add_one | null |
norm_dvd_iff {x : S} (hx : Prime (Algebra.norm ℤ x)) {y : ℤ} :
Algebra.norm ℤ x ∣ y ↔ x ∣ y := by
rw [← Ideal.mem_span_singleton (y := x), ← eq_intCast (algebraMap ℤ S), ← Ideal.mem_comap,
← Ideal.span_singleton_absNorm, Ideal.mem_span_singleton, Ideal.absNorm_span_singleton,
Int.natAbs_dvd]
rwa [Ideal.absNorm_span_singleton, ← Int.prime_iff_natAbs_prime] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | norm_dvd_iff | null |
@[simp]
Int.ideal_span_absNorm_eq_self (J : Ideal ℤ) :
span {(absNorm J : ℤ)} = J := by
obtain ⟨g, rfl⟩ := IsPrincipalIdealRing.principal J
simp | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Quotient",
"Mathlib.LinearAlgebra.FreeModule.Determinant",
"Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient",
"Mathlib.LinearAlgebra.FreeModule.IdealQuotient",
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas",
"Mathlib.RingTheory.Ideal... | Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean | Int.ideal_span_absNorm_eq_self | null |
noncomputable spanNorm (I : Ideal S) : Ideal R :=
Ideal.map (Algebra.intNorm R S) I
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm | `Ideal.spanNorm R (I : Ideal S)` is the ideal generated by mapping `Algebra.intNorm R S`
over `I`.
See also `Ideal.relNorm`. |
spanNorm_bot :
spanNorm R (⊥ : Ideal S) = ⊥ := span_eq_bot.mpr fun x hx => by simpa using hx
variable {R} in
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_bot | null |
spanNorm_eq_bot_iff {I : Ideal S} : spanNorm R I = ⊥ ↔ I = ⊥ := by
simp only [spanNorm, span_eq_bot, Set.mem_image, SetLike.mem_coe, forall_exists_index, and_imp,
forall_apply_eq_imp_iff₂, Algebra.intNorm_eq_zero, @eq_bot_iff _ _ _ I, SetLike.le_def, map,
mem_bot] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_eq_bot_iff | null |
intNorm_mem_spanNorm {I : Ideal S} {x : S} (hx : x ∈ I) :
Algebra.intNorm R S x ∈ I.spanNorm R :=
subset_span (Set.mem_image_of_mem _ hx) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | intNorm_mem_spanNorm | null |
norm_mem_spanNorm [Module.Free R S] {I : Ideal S} (x : S) (hx : x ∈ I) :
Algebra.norm R x ∈ I.spanNorm R := by
refine subset_span ⟨x, hx, ?_⟩
rw [Algebra.intNorm_eq_norm]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | norm_mem_spanNorm | null |
spanNorm_singleton {r : S} :
spanNorm R (span ({r} : Set S)) = span {Algebra.intNorm R S r} :=
le_antisymm
(span_le.mpr fun x hx =>
mem_span_singleton.mpr
(by
obtain ⟨x, hx', rfl⟩ := (Set.mem_image _ _ _).mp hx
exact map_dvd _ (mem_span_singleton.mp hx')))
((span_singleton_le_iff_mem _).mpr (intNorm_mem_spanNorm _ (mem_span_singleton_self _)))
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_singleton | null |
spanNorm_top : spanNorm R (⊤ : Ideal S) = ⊤ := by
simp [← Ideal.span_singleton_one] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_top | null |
map_spanIntNorm (I : Ideal S) {T : Type*} [Semiring T] (f : R →+* T) :
map f (spanNorm R I) = span (f ∘ Algebra.intNorm R S '' (I : Set S)) := by
rw [spanNorm]
nth_rw 2 [map]
simp [map_span, Set.image_image]
@[mono] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | map_spanIntNorm | null |
spanNorm_mono {I J : Ideal S} (h : I ≤ J) : spanNorm R I ≤ spanNorm R J :=
Ideal.span_mono (Set.monotone_image h) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_mono | null |
spanIntNorm_localization (I : Ideal S) (M : Submonoid R) (hM : M ≤ R⁰)
{Rₘ : Type*} (Sₘ : Type*) [CommRing Rₘ] [Algebra R Rₘ] [CommRing Sₘ] [Algebra S Sₘ]
[Algebra Rₘ Sₘ] [Algebra R Sₘ] [IsScalarTower R Rₘ Sₘ] [IsScalarTower R S Sₘ]
[IsLocalization M Rₘ] [IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ]
[IsIntegrallyClosed Rₘ] [IsDomain Rₘ] [IsDomain Sₘ] [NoZeroSMulDivisors Rₘ Sₘ]
[Module.Finite Rₘ Sₘ] [IsIntegrallyClosed Sₘ]
[Algebra.IsSeparable (FractionRing Rₘ) (FractionRing Sₘ)] :
spanNorm Rₘ (I.map (algebraMap S Sₘ)) = (spanNorm R I).map (algebraMap R Rₘ) := by
let K := FractionRing R
let f : Rₘ →+* K := IsLocalization.map _ (T := R⁰) (RingHom.id R) hM
let L := FractionRing S
let g : Sₘ →+* L := IsLocalization.map _ (M := Algebra.algebraMapSubmonoid S M) (T := S⁰)
(RingHom.id S) (Submonoid.map_le_of_le_comap _ <| hM.trans
(nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _
(FaithfulSMul.algebraMap_injective _ _)))
algebraize [f, g, (algebraMap K L).comp f]
have : IsScalarTower R Rₘ K := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
let _ := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization M Rₘ K
have : IsScalarTower S Sₘ L := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
have : IsScalarTower Rₘ Sₘ L := by
apply IsScalarTower.of_algebraMap_eq'
apply IsLocalization.ringHom_ext M
rw [RingHom.algebraMap_toAlgebra, RingHom.algebraMap_toAlgebra (R := Sₘ), RingHom.comp_assoc,
RingHom.comp_assoc, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq R S Sₘ,
IsLocalization.map_comp, RingHom.comp_id, ← RingHom.comp_assoc, IsLocalization.map_comp,
RingHom.comp_id, ← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq]
let _ := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization
(Algebra.algebraMapSubmonoid S M) Sₘ L
rw [map_spanIntNorm]
refine span_eq_span (Set.image_subset_iff.mpr ?_) (Set.image_subset_iff.mpr ?_)
· intro a' ha'
simp only [Set.mem_preimage, submodule_span_eq, ← map_spanIntNorm, SetLike.mem_coe,
IsLocalization.mem_map_algebraMap_iff (Algebra.algebraMapSubmonoid S M) Sₘ,
IsLocalization.mem_map_algebraMap_iff M Rₘ, Prod.exists] at ha' ⊢
obtain ⟨⟨a, ha⟩, ⟨_, ⟨s, hs, rfl⟩⟩, has⟩ := ha'
refine ⟨⟨Algebra.intNorm R S a, intNorm_mem_spanNorm _ ha⟩,
⟨s ^ Module.finrank K L, pow_mem hs _⟩, ?_⟩
simp only [map_pow] at has ⊢
apply_fun algebraMap _ L at has
apply_fun Algebra.norm K at has
simp only [map_mul] at has
rw [← IsScalarTower.algebraMap_apply, ← IsScalarTower.algebraMap_apply,
← IsScalarTower.algebraMap_apply,
IsScalarTower.algebraMap_apply R K L,
Algebra.norm_algebraMap] at has
apply IsFractionRing.injective Rₘ K
simp only [map_mul, map_pow]
rwa [Algebra.algebraMap_intNorm (L := L), ← IsScalarTower.algebraMap_apply,
← IsScalarTower.algebraMap_apply, Algebra.algebraMap_intNorm (L := L)]
... | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanIntNorm_localization | null |
spanNorm_mul_spanNorm_le (I J : Ideal S) :
spanNorm R I * spanNorm R J ≤ spanNorm R (I * J) := by
rw [spanNorm, spanNorm, spanNorm]
nth_rw 1 [map]; nth_rw 1 [map]
rw [Ideal.span_mul_span', ← Set.image_mul]
refine Ideal.span_mono (Set.monotone_image ?_)
rintro _ ⟨x, hxI, y, hyJ, rfl⟩
exact Ideal.mul_mem_mul hxI hyJ | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_mul_spanNorm_le | null |
spanNorm_mul_of_bot_or_top (eq_bot_or_top : ∀ I : Ideal R, I = ⊥ ∨ I = ⊤) (I J : Ideal S) :
spanNorm R (I * J) = spanNorm R I * spanNorm R J := by
refine le_antisymm ?_ (spanNorm_mul_spanNorm_le R _ _)
rcases eq_bot_or_top (spanNorm R I) with hI | hI
· rw [hI, spanNorm_eq_bot_iff.mp hI, bot_mul, spanNorm_bot]
exact bot_le
rw [hI, Ideal.top_mul]
rcases eq_bot_or_top (spanNorm R J) with hJ | hJ
· rw [hJ, spanNorm_eq_bot_iff.mp hJ, mul_bot, spanNorm_bot]
rw [hJ]
exact le_top | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_mul_of_bot_or_top | This condition `eq_bot_or_top` is equivalent to being a field.
However, `Ideal.spanNorm_mul_of_field` is harder to apply since we'd need to upgrade a `CommRing R`
instance to a `Field R` instance. |
spanNorm_le_comap (I : Ideal S) :
spanNorm R I ≤ comap (algebraMap R S) I := by
rw [spanNorm, Ideal.map, Ideal.span_le, ← Submodule.span_le]
intro x hx
induction hx using Submodule.span_induction with
| mem _ h =>
obtain ⟨x, hx, rfl⟩ := h
exact mem_comap.mpr <| mem_of_dvd _ (Algebra.dvd_algebraMap_intNorm_self _ _ x) hx
| zero => simp
| add _ _ _ _ hx hy => exact Submodule.add_mem _ hx hy
| smul _ _ _ hx => exact Submodule.smul_mem _ _ hx | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_le_comap | null |
spanNorm_mul [IsDedekindDomain R] [IsDedekindDomain S] (I J : Ideal S) :
spanNorm R (I * J) = spanNorm R I * spanNorm R J := by
nontriviality R
cases subsingleton_or_nontrivial S
· have : ∀ I : Ideal S, I = ⊤ := fun I ↦ Subsingleton.elim I ⊤
simp [this I, this J]
refine eq_of_localization_maximal (fun P hP ↦ ?_)
by_cases hP0 : P = ⊥
· subst hP0
rw [spanNorm_mul_of_bot_or_top]
intro I
exact or_iff_not_imp_right.mpr fun hI ↦ (hP.eq_of_le hI bot_le).symm
have : NeZero P := ⟨hP0⟩
let P' := Algebra.algebraMapSubmonoid S P.primeCompl
simp only [Ideal.map_mul, ← spanIntNorm_localization (R := R) (Sₘ := Localization P')
_ _ P.primeCompl_le_nonZeroDivisors]
rw [← (I.map _).span_singleton_generator, ← (J.map _).span_singleton_generator,
span_singleton_mul_span_singleton, spanNorm_singleton, spanNorm_singleton,
spanNorm_singleton, span_singleton_mul_span_singleton, map_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_mul | Multiplicativity of `Ideal.spanNorm`. simp-normal form is `map_mul (Ideal.relNorm R)`. |
le_spanNorm_spanNorm (I : Ideal S) : spanNorm R I ≤ spanNorm R (spanNorm T I) := by
simp_rw [spanNorm, map]
refine span_mono ?_
rintro _ ⟨x, hx, rfl⟩
exact ⟨intNorm T S x, subset_span <| Set.mem_image_of_mem _ hx, by rw [intNorm_intNorm]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | le_spanNorm_spanNorm | null |
spanNorm_spanNorm_of_bot_or_top (eq_bot_or_top : ∀ I : Ideal R, I = ⊥ ∨ I = ⊤)
(I : Ideal S) : spanNorm R (spanNorm T I) = spanNorm R I := by
obtain h | h := eq_bot_or_top (spanNorm R I)
· rw [h, spanNorm_eq_bot_iff, spanNorm_eq_bot_iff, spanNorm_eq_bot_iff.mp h]
· exact h ▸ (eq_top_iff_one _).mpr <| le_spanNorm_spanNorm R T I <| (eq_top_iff_one _).mp h
attribute [local instance] Localization.AtPrime.algebra_localization_localization | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_spanNorm_of_bot_or_top | This condition `eq_bot_or_top` is equivalent to being a field. However,
`Ideal.spanNorm_spanNorm_of_field` would be harder to apply since we'd need to upgrade
a `CommRing R` instance to a `Field R` instance. |
spanNorm_spanNorm [IsDedekindDomain R] [IsDedekindDomain T] [IsDedekindDomain S]
(I : Ideal S) : spanNorm R (spanNorm T I) = spanNorm R I := by
refine eq_of_localization_maximal fun P hP ↦ ?_
by_cases hP : P = ⊥
· subst hP
rw [spanNorm_spanNorm_of_bot_or_top]
exact fun I ↦ or_iff_not_imp_right.mpr fun hI ↦ (hP.eq_of_le hI bot_le).symm
let Rₚ := Localization.AtPrime P
let Tₚ := Localization (algebraMapSubmonoid T P.primeCompl)
let Sₚ := Localization (algebraMapSubmonoid S P.primeCompl)
have : NeZero P := ⟨hP⟩
have h : algebraMapSubmonoid T P.primeCompl ≤ T⁰ :=
algebraMapSubmonoid_le_nonZeroDivisors_of_faithfulSMul _ (primeCompl_le_nonZeroDivisors P)
rw [← spanIntNorm_localization R (spanNorm T I) _ (primeCompl_le_nonZeroDivisors P) Tₚ,
← spanIntNorm_localization T (Rₘ := Tₚ) I _ h Sₚ, ← spanIntNorm_localization R (Rₘ := Rₚ) I _
(primeCompl_le_nonZeroDivisors P) Sₚ, ← (I.map _).span_singleton_generator, spanNorm_singleton,
spanNorm_singleton, intNorm_intNorm, spanNorm_singleton] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_spanNorm | null |
noncomputable relNorm : Ideal S →*₀ Ideal R where
toFun := spanNorm R
map_zero' := spanNorm_bot R
map_one' := by rw [one_eq_top, spanNorm_top R, one_eq_top]
map_mul' := spanNorm_mul R | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm | The relative norm `Ideal.relNorm R (I : Ideal S)`, where `R` and `S` are Dedekind domains,
and `S` is an extension of `R` that is finite and free as a module. |
relNorm_apply (I : Ideal S) :
relNorm R I = span (Algebra.intNorm R S '' (I : Set S) : Set R) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_apply | null |
spanNorm_eq (I : Ideal S) : spanNorm R I = relNorm R I := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | spanNorm_eq | null |
relNorm_bot : relNorm R (⊥ : Ideal S) = ⊥ := by
simpa only [zero_eq_bot] using map_zero (relNorm R : Ideal S →*₀ _)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_bot | null |
relNorm_top : relNorm R (⊤ : Ideal S) = ⊤ := by
simpa only [one_eq_top] using map_one (relNorm R : Ideal S →*₀ _)
variable {R} in
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_top | null |
relNorm_eq_bot_iff {I : Ideal S} : relNorm R I = ⊥ ↔ I = ⊥ :=
spanNorm_eq_bot_iff | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_eq_bot_iff | null |
norm_mem_relNorm [Module.Free R S] (I : Ideal S) {x : S} (hx : x ∈ I) :
Algebra.norm R x ∈ relNorm R I :=
norm_mem_spanNorm R x hx
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | norm_mem_relNorm | null |
relNorm_singleton (r : S) : relNorm R (span ({r} : Set S)) = span {Algebra.intNorm R S r} :=
spanNorm_singleton R | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_singleton | null |
map_relNorm (I : Ideal S) {T : Type*} [Semiring T] (f : R →+* T) :
map f (relNorm R I) = span (f ∘ Algebra.intNorm R S '' (I : Set S)) :=
map_spanIntNorm R I f
@[mono] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | map_relNorm | null |
relNorm_mono {I J : Ideal S} (h : I ≤ J) : relNorm R I ≤ relNorm R J :=
spanNorm_mono R h
variable {R} | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_mono | null |
private relNorm_map_algEquiv_aux {T : Type*} [CommRing T] [IsDedekindDomain T]
[IsIntegrallyClosed T] [Algebra R T] [Module.Finite R T] [NoZeroSMulDivisors R T]
[Algebra.IsSeparable (FractionRing R) (FractionRing T)] (σ : S ≃ₐ[R] T) (I : Ideal S) :
relNorm R (I.map σ) ≤ relNorm R I :=
span_mono fun _ ⟨x, hx₁, hx₂⟩ ↦ ⟨σ.toRingEquiv.symm x,
by rwa [SetLike.mem_coe, Ideal.symm_apply_mem_of_equiv_iff],
hx₂ ▸ Algebra.intNorm_map_algEquiv _ x σ.symm⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_map_algEquiv_aux | null |
relNorm_map_algEquiv {T : Type*} [CommRing T] [IsDedekindDomain T] [IsIntegrallyClosed T]
[Algebra R T] [Module.Finite R T] [NoZeroSMulDivisors R T]
[Algebra.IsSeparable (FractionRing R) (FractionRing T)] (σ : S ≃ₐ[R] T) (I : Ideal S) :
relNorm R (I.map σ) = relNorm R I := by
refine le_antisymm (relNorm_map_algEquiv_aux σ I) ?_
convert relNorm_map_algEquiv_aux σ.symm (I.map σ)
change I = map σ.symm.toAlgHom (map σ.toAlgHom I)
simp [map_mapₐ]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_map_algEquiv | null |
relNorm_comap_algEquiv {T : Type*} [CommRing T] [IsDedekindDomain T] [IsIntegrallyClosed T]
[Algebra R T] [Module.Finite R T] [NoZeroSMulDivisors R T]
[Algebra.IsSeparable (FractionRing R) (FractionRing T)] (σ : S ≃ₐ[R] T) (I : Ideal T) :
relNorm R (I.comap σ) = relNorm R I := map_symm σ.toRingEquiv ▸ relNorm_map_algEquiv σ.symm I
variable (R)
open MulSemiringAction Pointwise in
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_comap_algEquiv | null |
relNorm_smul {G : Type*} [Group G] [MulSemiringAction G S] [SMulCommClass G R S] (g : G)
(I : Ideal S) : relNorm R (g • I) = relNorm R I := relNorm_map_algEquiv (toAlgEquiv R S g) I | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_smul | null |
relNorm_le_comap (I : Ideal S) :
relNorm R I ≤ comap (algebraMap R S) I := spanNorm_le_comap R I | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_le_comap | null |
relNorm_relNorm (T : Type*) [CommRing T] [IsDedekindDomain T] [IsIntegrallyClosed T]
[Algebra R T] [Algebra T S] [IsScalarTower R T S] [Module.Finite R T] [Module.Finite T S]
[NoZeroSMulDivisors R T] [NoZeroSMulDivisors T S]
[Algebra.IsSeparable (FractionRing R) (FractionRing T)]
[Algebra.IsSeparable (FractionRing T) (FractionRing S)]
(I : Ideal S) : relNorm R (relNorm T I) = relNorm R I :=
spanNorm_spanNorm _ _ _
variable {R} (S)
attribute [local instance] Localization.AtPrime.liftAlgebra in | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_relNorm | null |
relNorm_algebraMap (I : Ideal R) :
relNorm R (I.map (algebraMap R S)) =
I ^ Module.finrank (FractionRing R) (FractionRing S) := by
rw [← spanNorm_eq]
refine eq_of_localization_maximal (fun P hPd ↦ ?_)
let P' := Algebra.algebraMapSubmonoid S P.primeCompl
let Rₚ := Localization.AtPrime P
let K := FractionRing R
rw [← spanIntNorm_localization R _ _ P.primeCompl_le_nonZeroDivisors (Localization P'),
Ideal.map_pow, I.map_map, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq R Rₚ,
← I.map_map, ← (I.map _).span_singleton_generator, Ideal.map_span, Set.image_singleton,
spanNorm_singleton, Ideal.span_singleton_pow]
congr 2
apply IsFractionRing.injective Rₚ K
rw [Algebra.algebraMap_intNorm (L := FractionRing S), ← IsScalarTower.algebraMap_apply,
IsScalarTower.algebraMap_apply Rₚ K, Algebra.norm_algebraMap, map_pow]
variable (R) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_algebraMap | null |
relNorm_algebraMap' {R'} [CommRing R'] (I : Ideal R') [Algebra R' R]
[Algebra R' S] [IsScalarTower R' R S] : relNorm R (I.map (algebraMap R' S)) =
I.map (algebraMap R' R) ^ Module.finrank (FractionRing R) (FractionRing S) := by
rw [← relNorm_algebraMap, Ideal.map_map, IsScalarTower.algebraMap_eq R' R S] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Instances",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Ideal/Norm/RelNorm.lean | relNorm_algebraMap' | A version of `relNorm_algebraMap` involving a tower of algebras `S/R/R'`. |
zero_eq_one_iff : (0 : R ⧸ I) = 1 ↔ I = ⊤ :=
eq_comm.trans <| (Submodule.Quotient.mk_eq_zero _).trans (eq_top_iff_one _).symm | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | zero_eq_one_iff | null |
zero_ne_one_iff : (0 : R ⧸ I) ≠ 1 ↔ I ≠ ⊤ :=
not_congr zero_eq_one_iff | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | zero_ne_one_iff | null |
protected nontrivial (hI : I ≠ ⊤) : Nontrivial (R ⧸ I) :=
⟨⟨0, 1, zero_ne_one_iff.2 hI⟩⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | nontrivial | null |
subsingleton_iff : Subsingleton (R ⧸ I) ↔ I = ⊤ := by
rw [Submodule.Quotient.subsingleton_iff, eq_top_iff, SetLike.le_def]
simp_rw [Submodule.mem_top, true_implies] | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | subsingleton_iff | null |
smulCommClass {α} [SMul α R] [IsScalarTower α R R] [SMulCommClass α R R] :
SMulCommClass α (R ⧸ I) (R ⧸ I) :=
(Quotient.ringCon I).smulCommClass | instance | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | smulCommClass | null |
smulCommClass' {α} [SMul α R] [IsScalarTower α R R] [SMulCommClass R α R] :
SMulCommClass (R ⧸ I) α (R ⧸ I) :=
(Quotient.ringCon I).smulCommClass' | instance | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | smulCommClass' | null |
eq_zero_iff_dvd {R} [CommRing R] (x y : R) :
Ideal.Quotient.mk (Ideal.span ({x} : Set R)) y = 0 ↔ x ∣ y := by
rw [Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton]
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | eq_zero_iff_dvd | null |
mk_singleton_self (x : R) [(Ideal.span {x}).IsTwoSided] : mk (Ideal.span {x}) x = 0 :=
(Submodule.Quotient.mk_eq_zero _).mpr (mem_span_singleton_self _)
variable (I) | lemma | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | mk_singleton_self | null |
noZeroDivisors [hI : I.IsPrime] : NoZeroDivisors (R ⧸ I) where
eq_zero_or_eq_zero_of_mul_eq_zero {a b} := Quotient.inductionOn₂' a b fun {_ _} hab =>
(hI.mem_or_mem (eq_zero_iff_mem.1 hab)).elim (Or.inl ∘ eq_zero_iff_mem.2)
(Or.inr ∘ eq_zero_iff_mem.2) | instance | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | noZeroDivisors | null |
isDomain [hI : I.IsPrime] : IsDomain (R ⧸ I) :=
let _ := Quotient.nontrivial hI.1
NoZeroDivisors.to_isDomain _ | instance | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | isDomain | null |
isDomain_iff_prime : IsDomain (R ⧸ I) ↔ I.IsPrime := by
refine ⟨fun H => ⟨zero_ne_one_iff.1 ?_, fun {x y} h => ?_⟩, fun h => inferInstance⟩
· haveI : Nontrivial (R ⧸ I) := ⟨H.2.1⟩
exact zero_ne_one
· simp only [← eq_zero_iff_mem, (mk I).map_mul] at h ⊢
haveI := @IsDomain.to_noZeroDivisors (R ⧸ I) _ H
exact eq_zero_or_eq_zero_of_mul_eq_zero h
variable {I} in | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | isDomain_iff_prime | null |
exists_inv [hI : I.IsMaximal] :
∀ {a : R ⧸ I}, a ≠ 0 → ∃ b : R ⧸ I, a * b = 1 := by
apply exists_right_inv_of_exists_left_inv
rintro ⟨a⟩ h
rcases hI.exists_inv (mt eq_zero_iff_mem.2 h) with ⟨b, c, hc, abc⟩
refine ⟨mk _ b, Quot.sound ?_⟩
simp only [Submodule.quotientRel_def]
rw [← eq_sub_iff_add_eq'] at abc
rwa [abc, ← neg_mem_iff (G := R) (H := I), neg_sub] at hc
open Classical in | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | exists_inv | null |
protected noncomputable groupWithZero [hI : I.IsMaximal] :
GroupWithZero (R ⧸ I) := fast_instance%
{ inv := fun a => if ha : a = 0 then 0 else Classical.choose (exists_inv ha)
mul_inv_cancel := fun a (ha : a ≠ 0) =>
show a * dite _ _ _ = _ by rw [dif_neg ha]; exact Classical.choose_spec (exists_inv ha)
inv_zero := dif_pos rfl
__ := Quotient.nontrivial hI.out.1 } | abbrev | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | groupWithZero | The quotient by a maximal ideal is a group with zero. This is a `def` rather than `instance`,
since users will have computable inverses in some applications.
See note [reducible non-instances]. |
protected noncomputable divisionRing [I.IsMaximal] : DivisionRing (R ⧸ I) := fast_instance%
{ __ := ring _
__ := Quotient.groupWithZero _
nnqsmul := _
nnqsmul_def _ _ := rfl
qsmul := _
qsmul_def _ _ := rfl } | abbrev | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | divisionRing | The quotient by a two-sided ideal that is maximal as a left ideal is a division ring.
This is a `def` rather than `instance`, since users
will have computable inverses (and `qsmul`, `ratCast`) in some applications.
See note [reducible non-instances]. |
protected noncomputable field {R} [CommRing R] (I : Ideal R) [I.IsMaximal] :
Field (R ⧸ I) := fast_instance%
{ __ := commRing _
__ := Quotient.divisionRing I } | abbrev | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | field | The quotient of a commutative ring by a maximal ideal is a field.
This is a `def` rather than `instance`, since users
will have computable inverses (and `qsmul`, `ratCast`) in some applications.
See note [reducible non-instances]. |
maximal_of_isField {R} [CommRing R] (I : Ideal R) (hqf : IsField (R ⧸ I)) :
I.IsMaximal := by
apply Ideal.isMaximal_iff.2
constructor
· intro h
rcases hqf.exists_pair_ne with ⟨⟨x⟩, ⟨y⟩, hxy⟩
exact hxy (Ideal.Quotient.eq.2 (mul_one (x - y) ▸ I.mul_mem_left _ h))
· intro J x hIJ hxnI hxJ
rcases hqf.mul_inv_cancel (mt Ideal.Quotient.eq_zero_iff_mem.1 hxnI) with ⟨⟨y⟩, hy⟩
rw [← zero_add (1 : R), ← sub_self (x * y), sub_add]
exact J.sub_mem (J.mul_mem_right _ hxJ) (hIJ (Ideal.Quotient.eq.1 hy)) | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | maximal_of_isField | If the quotient by an ideal is a field, then the ideal is maximal. |
maximal_ideal_iff_isField_quotient {R} [CommRing R] (I : Ideal R) :
I.IsMaximal ↔ IsField (R ⧸ I) :=
⟨fun h =>
let _i := @Quotient.field _ _ I h
Field.toIsField _,
maximal_of_isField _⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | maximal_ideal_iff_isField_quotient | The quotient of a ring by an ideal is a field iff the ideal is maximal. |
modulePi [I.IsTwoSided] : Module (R ⧸ I) ((ι → R) ⧸ pi fun _ ↦ I) where
smul c m :=
Quotient.liftOn₂' c m (fun r m ↦ Submodule.Quotient.mk <| r • m) <| by
intro c₁ m₁ c₂ m₂ hc hm
apply Ideal.Quotient.eq.2
rw [Submodule.quotientRel_def] at hc hm
intro i
exact I.mul_sub_mul_mem hc (hm i)
one_smul := by rintro ⟨a⟩; exact congr_arg _ (one_smul _ _)
mul_smul := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; exact congr_arg _ (mul_smul _ _ _)
smul_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; exact congr_arg _ (smul_add _ _ _)
smul_zero := by rintro ⟨a⟩; exact congr_arg _ (smul_zero _)
add_smul := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; exact congr_arg _ (add_smul _ _ _)
zero_smul := by rintro ⟨a⟩; exact congr_arg _ (zero_smul _ _) | instance | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | modulePi | `R^n/I^n` is a `R/I`-module. |
noncomputable piQuotEquiv [I.IsTwoSided] : ((ι → R) ⧸ pi fun _ ↦ I) ≃ₗ[R ⧸ I] ι → (R ⧸ I) where
toFun x := Quotient.liftOn' x (fun f i ↦ Ideal.Quotient.mk I (f i)) fun _ _ hab ↦
funext fun i ↦ (Submodule.Quotient.eq' _).2 (QuotientAddGroup.leftRel_apply.mp hab i)
map_add' := by rintro ⟨_⟩ ⟨_⟩; rfl
map_smul' := by rintro ⟨_⟩ ⟨_⟩; rfl
invFun x := Ideal.Quotient.mk _ (Quotient.out <| x ·)
left_inv := by
rintro ⟨x⟩
exact Ideal.Quotient.eq.2 fun i ↦ Ideal.Quotient.eq.1 (Quotient.out_eq' _)
right_inv x := funext fun i ↦ Quotient.out_eq' (x i) | def | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | piQuotEquiv | `R^n/I^n` is isomorphic to `(R/I)^n` as an `R/I`-module. |
map_pi [I.IsTwoSided] {ι : Type*} [Finite ι] {ι' : Type w} (x : ι → R) (hi : ∀ i, x i ∈ I)
(f : (ι → R) →ₗ[R] ι' → R) (i : ι') : f x i ∈ I := by
classical
cases nonempty_fintype ι
rw [pi_eq_sum_univ x]
simp only [Finset.sum_apply, smul_eq_mul, map_sum, Pi.smul_apply, map_smul]
exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j) | theorem | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | map_pi | If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
contained in `I^m`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.