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 ⌀ |
|---|---|---|---|---|---|---|
extendedHomₐ : FractionalIdeal A⁰ K →+* FractionalIdeal B⁰ L :=
extendedHom L <|
nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _ (FaithfulSMul.algebraMap_injective _ _) | abbrev | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic"
] | Mathlib/RingTheory/FractionalIdeal/Extended.lean | extendedHomₐ | The ring homomorphisme that extends a fractional ideal of `A` to a fractional ideal of `B` for
`A ⊆ B` an extension of domains. |
inv_eq : I⁻¹ = 1 / I := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | inv_eq | null |
inv_zero' : (0 : FractionalIdeal R₁⁰ K)⁻¹ = 0 := div_zero | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | inv_zero' | null |
inv_nonzero {J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
J⁻¹ = ⟨(1 : FractionalIdeal R₁⁰ K) / J, fractional_div_of_nonzero h⟩ := div_nonzero h | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | inv_nonzero | null |
coe_inv_of_nonzero {J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
(↑J⁻¹ : Submodule R₁ K) = IsLocalization.coeSubmodule K ⊤ / (J : Submodule R₁ K) := by
simp_rw [inv_nonzero _ h, coe_one, coe_mk, IsLocalization.coeSubmodule_top]
variable {K} | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | coe_inv_of_nonzero | null |
mem_inv_iff (hI : I ≠ 0) {x : K} : x ∈ I⁻¹ ↔ ∀ y ∈ I, x * y ∈ (1 : FractionalIdeal R₁⁰ K) :=
mem_div_iff_of_nonzero hI | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | mem_inv_iff | null |
inv_anti_mono (hI : I ≠ 0) (hJ : J ≠ 0) (hIJ : I ≤ J) : J⁻¹ ≤ I⁻¹ := by
intro x
simp only [val_eq_coe, mem_coe, mem_inv_iff hJ, mem_inv_iff hI]
exact fun h y hy => h y (hIJ hy) | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | inv_anti_mono | null |
le_self_mul_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≤ (1 : FractionalIdeal R₁⁰ K)) :
I ≤ I * I⁻¹ :=
le_self_mul_one_div hI
variable (K) | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | le_self_mul_inv | null |
coe_ideal_le_self_mul_inv (I : Ideal R₁) :
(I : FractionalIdeal R₁⁰ K) ≤ I * (I : FractionalIdeal R₁⁰ K)⁻¹ :=
le_self_mul_inv coeIdeal_le_one | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | coe_ideal_le_self_mul_inv | null |
right_inverse_eq (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) : J = I⁻¹ := by
have hI : I ≠ 0 := ne_zero_of_mul_eq_one I J h
suffices h' : I * (1 / I) = 1 from
congr_arg Units.inv <| @Units.ext _ _ (Units.mkOfMulEqOne _ _ h) (Units.mkOfMulEqOne _ _ h') rfl
apply le_antisymm
· apply mul_le.mpr _
intro x hx y hy
rw [mul_comm]
exact (mem_div_iff_of_nonzero hI).mp hy x hx
rw [← h]
apply mul_left_mono I
apply (le_div_iff_of_nonzero hI).mpr _
intro y hy x hx
rw [mul_comm]
exact mul_mem_mul hy hx | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | right_inverse_eq | `I⁻¹` is the inverse of `I` if `I` has an inverse. |
mul_inv_cancel_iff {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ ∃ J, I * J = 1 :=
⟨fun h => ⟨I⁻¹, h⟩, fun ⟨J, hJ⟩ => by rwa [← right_inverse_eq K I J hJ]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | mul_inv_cancel_iff | null |
mul_inv_cancel_iff_isUnit {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ IsUnit I :=
(mul_inv_cancel_iff K).trans isUnit_iff_exists_inv.symm
variable {K' : Type*} [Field K'] [Algebra R₁ K'] [IsFractionRing R₁ K']
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | mul_inv_cancel_iff_isUnit | null |
protected map_inv (I : FractionalIdeal R₁⁰ K) (h : K ≃ₐ[R₁] K') :
I⁻¹.map (h : K →ₐ[R₁] K') = (I.map h)⁻¹ := by
rw [inv_eq, FractionalIdeal.map_div, FractionalIdeal.map_one, inv_eq]
open Submodule Submodule.IsPrincipal
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | map_inv | null |
spanSingleton_inv (x : K) : (spanSingleton R₁⁰ x)⁻¹ = spanSingleton _ x⁻¹ :=
one_div_spanSingleton x | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | spanSingleton_inv | null |
spanSingleton_div_spanSingleton (x y : K) :
spanSingleton R₁⁰ x / spanSingleton R₁⁰ y = spanSingleton R₁⁰ (x / y) := by
rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | spanSingleton_div_spanSingleton | null |
spanSingleton_div_self {x : K} (hx : x ≠ 0) :
spanSingleton R₁⁰ x / spanSingleton R₁⁰ x = 1 := by
rw [spanSingleton_div_spanSingleton, div_self hx, spanSingleton_one] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | spanSingleton_div_self | null |
coe_ideal_span_singleton_div_self {x : R₁} (hx : x ≠ 0) :
(Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K) / Ideal.span ({x} : Set R₁) = 1 := by
rw [coeIdeal_span_singleton,
spanSingleton_div_self K <|
(map_ne_zero_iff _ <| FaithfulSMul.algebraMap_injective R₁ K).mpr hx] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | coe_ideal_span_singleton_div_self | null |
spanSingleton_mul_inv {x : K} (hx : x ≠ 0) :
spanSingleton R₁⁰ x * (spanSingleton R₁⁰ x)⁻¹ = 1 := by
rw [spanSingleton_inv, spanSingleton_mul_spanSingleton, mul_inv_cancel₀ hx, spanSingleton_one] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | spanSingleton_mul_inv | null |
coe_ideal_span_singleton_mul_inv {x : R₁} (hx : x ≠ 0) :
(Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K) *
(Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K)⁻¹ = 1 := by
rw [coeIdeal_span_singleton,
spanSingleton_mul_inv K <|
(map_ne_zero_iff _ <| FaithfulSMul.algebraMap_injective R₁ K).mpr hx] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | coe_ideal_span_singleton_mul_inv | null |
spanSingleton_inv_mul {x : K} (hx : x ≠ 0) :
(spanSingleton R₁⁰ x)⁻¹ * spanSingleton R₁⁰ x = 1 := by
rw [mul_comm, spanSingleton_mul_inv K hx] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | spanSingleton_inv_mul | null |
coe_ideal_span_singleton_inv_mul {x : R₁} (hx : x ≠ 0) :
(Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K)⁻¹ * Ideal.span ({x} : Set R₁) = 1 := by
rw [mul_comm, coe_ideal_span_singleton_mul_inv K hx] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | coe_ideal_span_singleton_inv_mul | null |
mul_generator_self_inv {R₁ : Type*} [CommRing R₁] [Algebra R₁ K] [IsLocalization R₁⁰ K]
(I : FractionalIdeal R₁⁰ K) [Submodule.IsPrincipal (I : Submodule R₁ K)] (h : I ≠ 0) :
I * spanSingleton _ (generator (I : Submodule R₁ K))⁻¹ = 1 := by
conv_lhs => congr; rw [eq_spanSingleton_of_principal I]
rw [spanSingleton_mul_spanSingleton, mul_inv_cancel₀, spanSingleton_one]
intro generator_I_eq_zero
apply h
rw [eq_spanSingleton_of_principal I, generator_I_eq_zero, spanSingleton_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | mul_generator_self_inv | null |
invertible_of_principal (I : FractionalIdeal R₁⁰ K)
[Submodule.IsPrincipal (I : Submodule R₁ K)] (h : I ≠ 0) : I * I⁻¹ = 1 :=
mul_div_self_cancel_iff.mpr
⟨spanSingleton _ (generator (I : Submodule R₁ K))⁻¹, mul_generator_self_inv _ I h⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | invertible_of_principal | null |
invertible_iff_generator_nonzero (I : FractionalIdeal R₁⁰ K)
[Submodule.IsPrincipal (I : Submodule R₁ K)] :
I * I⁻¹ = 1 ↔ generator (I : Submodule R₁ K) ≠ 0 := by
constructor
· intro hI hg
apply ne_zero_of_mul_eq_one _ _ hI
rw [eq_spanSingleton_of_principal I, hg, spanSingleton_zero]
· intro hg
apply invertible_of_principal
rw [eq_spanSingleton_of_principal I]
intro hI
have := mem_spanSingleton_self R₁⁰ (generator (I : Submodule R₁ K))
rw [hI, mem_zero_iff] at this
contradiction | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | invertible_iff_generator_nonzero | null |
isPrincipal_inv (I : FractionalIdeal R₁⁰ K) [Submodule.IsPrincipal (I : Submodule R₁ K)]
(h : I ≠ 0) : Submodule.IsPrincipal I⁻¹.1 := by
rw [val_eq_coe, isPrincipal_iff]
use (generator (I : Submodule R₁ K))⁻¹
have hI : I * spanSingleton _ (generator (I : Submodule R₁ K))⁻¹ = 1 :=
mul_generator_self_inv _ I h
exact (right_inverse_eq _ I (spanSingleton _ (generator (I : Submodule R₁ K))⁻¹) hI).symm
variable {K} | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | isPrincipal_inv | null |
den_mem_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) :
(algebraMap R₁ K) (I.den : R₁) ∈ I⁻¹ := by
rw [mem_inv_iff hI]
intro i hi
rw [← Algebra.smul_def (I.den : R₁) i, ← mem_coe, coe_one]
suffices Submodule.map (Algebra.linearMap R₁ K) I.num ≤ 1 from
this <| (den_mul_self_eq_num I).symm ▸ smul_mem_pointwise_smul i I.den I.coeToSubmodule hi
apply le_trans <| map_mono (show I.num ≤ 1 by simp only [Ideal.one_eq_top, le_top])
rw [Ideal.one_eq_top, Submodule.map_top, one_eq_range] | lemma | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | den_mem_inv | null |
num_le_mul_inv (I : FractionalIdeal R₁⁰ K) : I.num ≤ I * I⁻¹ := by
by_cases hI : I = 0
· rw [hI, num_zero_eq <| FaithfulSMul.algebraMap_injective R₁ K, zero_mul, zero_eq_bot,
coeIdeal_bot]
· rw [mul_comm, ← den_mul_self_eq_num']
exact mul_right_mono I <| spanSingleton_le_iff_mem.2 (den_mem_inv hI) | lemma | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | num_le_mul_inv | null |
bot_lt_mul_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) : ⊥ < I * I⁻¹ :=
lt_of_lt_of_le (coeIdeal_ne_zero.2 (hI ∘ num_eq_zero_iff.1)).bot_lt I.num_le_mul_inv | lemma | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Operations"
] | Mathlib/RingTheory/FractionalIdeal/Inverse.lean | bot_lt_mul_inv | null |
absNorm_div_norm_eq_absNorm_div_norm {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
(h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
(Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)| =
(Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a : R)| := by
rw [div_eq_div_iff]
· replace h := congr_arg (I.den • ·) h
have h' := congr_arg (a • ·) (den_mul_self_eq_num I)
dsimp only at h h'
rw [smul_comm] at h
rw [h, Submonoid.smul_def, Submonoid.smul_def, ← Submodule.ideal_span_singleton_smul,
← Submodule.ideal_span_singleton_smul, ← Submodule.map_smul'', ← Submodule.map_smul'',
(LinearMap.map_injective ?_).eq_iff, smul_eq_mul, smul_eq_mul] at h'
· simp_rw [← Int.cast_natAbs, ← Nat.cast_mul, ← Ideal.absNorm_span_singleton]
rw [← map_mul, ← map_mul, mul_comm, ← h', mul_comm]
· exact LinearMap.ker_eq_bot.mpr (IsFractionRing.injective R K)
all_goals simp [Algebra.norm_eq_zero_iff] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_div_norm_eq_absNorm_div_norm | null |
noncomputable absNorm : FractionalIdeal R⁰ K →*₀ ℚ where
toFun I := (Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)|
map_zero' := by
rw [num_zero_eq, Submodule.zero_eq_bot, Ideal.absNorm_bot, Nat.cast_zero, zero_div]
exact IsFractionRing.injective R K
map_one' := by
rw [absNorm_div_norm_eq_absNorm_div_norm 1 ⊤ (by simp [Submodule.one_eq_range]),
Ideal.absNorm_top, Nat.cast_one, OneMemClass.coe_one, map_one, abs_one,
Int.cast_one,
one_div_one]
map_mul' I J := by
rw [absNorm_div_norm_eq_absNorm_div_norm (I.den * J.den) (I.num * J.num) (by
have : Algebra.linearMap R K = (IsScalarTower.toAlgHom R R K).toLinearMap := rfl
rw [coe_mul, this, Submodule.map_mul, ← this, ← den_mul_self_eq_num, ← den_mul_self_eq_num]
exact Submodule.mul_smul_mul_eq_smul_mul_smul _ _ _ _),
Submonoid.coe_mul, map_mul, map_mul, Nat.cast_mul, div_mul_div_comm,
Int.cast_abs, Int.cast_abs, Int.cast_abs, ← abs_mul, Int.cast_mul] | def | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm | The absolute norm of the fractional ideal `I` extending by multiplicativity the absolute norm
on (integral) ideals. |
absNorm_eq (I : FractionalIdeal R⁰ K) :
absNorm I = (Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)| := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_eq | null |
absNorm_eq' {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
(h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
absNorm I = (Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a : R)| := by
rw [absNorm, ← absNorm_div_norm_eq_absNorm_div_norm a I₀ h, MonoidWithZeroHom.coe_mk,
ZeroHom.coe_mk] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_eq' | null |
absNorm_nonneg (I : FractionalIdeal R⁰ K) : 0 ≤ absNorm I := by dsimp [absNorm]; positivity | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_nonneg | null |
absNorm_bot : absNorm (⊥ : FractionalIdeal R⁰ K) = 0 := absNorm.map_zero' | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_bot | null |
absNorm_one : absNorm (1 : FractionalIdeal R⁰ K) = 1 := by convert absNorm.map_one' | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_one | null |
absNorm_eq_zero_iff [NoZeroDivisors K] {I : FractionalIdeal R⁰ K} :
absNorm I = 0 ↔ I = 0 := by
refine ⟨fun h ↦ zero_of_num_eq_bot zero_notMem_nonZeroDivisors ?_, fun h ↦ h ▸ absNorm_bot⟩
rw [absNorm_eq, div_eq_zero_iff] at h
refine Ideal.absNorm_eq_zero_iff.mp <| Nat.cast_eq_zero.mp <| h.resolve_right ?_
simp [Algebra.norm_eq_zero_iff] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_eq_zero_iff | null |
coeIdeal_absNorm (I₀ : Ideal R) :
absNorm (I₀ : FractionalIdeal R⁰ K) = Ideal.absNorm I₀ := by
rw [absNorm_eq' 1 I₀ (by rw [one_smul]; rfl), OneMemClass.coe_one, map_one, abs_one,
Int.cast_one, _root_.div_one] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | coeIdeal_absNorm | null |
abs_det_basis_change [NoZeroDivisors K] {ι : Type*} [Fintype ι]
[DecidableEq ι] (b : Basis ι ℤ R) (I : FractionalIdeal R⁰ K) (bI : Basis ι ℤ I) :
|(b.localizationLocalization ℚ ℤ⁰ K).det ((↑) ∘ bI)| = absNorm I := by
have := IsFractionRing.nontrivial R K
let b₀ : Basis ι ℚ K := b.localizationLocalization ℚ ℤ⁰ K
let bI.num : Basis ι ℤ I.num := bI.map
((equivNum (nonZeroDivisors.coe_ne_zero _)).restrictScalars ℤ)
rw [absNorm_eq, ← Ideal.natAbs_det_basis_change b I.num bI.num, Int.cast_natAbs, Int.cast_abs,
Int.cast_abs, Basis.det_apply, Basis.det_apply]
change _ = |algebraMap ℤ ℚ _| / _
rw [RingHom.map_det, show RingHom.mapMatrix (algebraMap ℤ ℚ) (b.toMatrix ((↑) ∘ bI.num)) =
b₀.toMatrix ((algebraMap R K (den I : R)) • ((↑) ∘ bI)) by
ext : 2
simp_rw [bI.num, RingHom.mapMatrix_apply, Matrix.map_apply, Basis.toMatrix_apply,
← Basis.localizationLocalization_repr_algebraMap ℚ ℤ⁰ K, Function.comp_apply,
Basis.map_apply, LinearEquiv.restrictScalars_apply, equivNum_apply, Submonoid.smul_def,
Algebra.smul_def]
rfl]
rw [Basis.toMatrix_smul, Matrix.det_mul, abs_mul, ← Algebra.norm_eq_matrix_det,
Algebra.norm_localization ℤ ℤ⁰, show (Algebra.norm ℤ (den I : R) : ℚ) =
algebraMap ℤ ℚ (Algebra.norm ℤ (den I : R)) by rfl, mul_div_assoc, mul_div_cancel₀ _ (by
rw [ne_eq, abs_eq_zero, IsFractionRing.to_map_eq_zero_iff, Algebra.norm_eq_zero_iff_of_basis b]
exact nonZeroDivisors.coe_ne_zero _)]
variable (R) in
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | abs_det_basis_change | null |
absNorm_span_singleton [Module.Finite ℚ K] (x : K) :
absNorm (spanSingleton R⁰ x) = |(Algebra.norm ℚ x)| := by
have : IsDomain K := IsFractionRing.isDomain R
obtain ⟨d, ⟨r, hr⟩⟩ := IsLocalization.exists_integer_multiple R⁰ x
rw [absNorm_eq' d (Ideal.span {r})]
· rw [Ideal.absNorm_span_singleton]
simp_rw [Int.cast_natAbs, Int.cast_abs, show ((Algebra.norm ℤ _) : ℚ) = algebraMap ℤ ℚ
(Algebra.norm ℤ _) by rfl, ← Algebra.norm_localization ℤ ℤ⁰ (Sₘ := K) _]
rw [hr, Algebra.smul_def, map_mul, abs_mul, mul_div_assoc, mul_div_cancel₀ _ (by
rw [ne_eq, abs_eq_zero, Algebra.norm_eq_zero_iff, IsFractionRing.to_map_eq_zero_iff]
exact nonZeroDivisors.coe_ne_zero _)]
· ext
simp_rw [Submodule.mem_smul_pointwise_iff_exists, mem_coe, mem_spanSingleton, Submodule.mem_map,
Algebra.linearMap_apply, Submonoid.smul_def, Ideal.mem_span_singleton', exists_exists_eq_and,
map_mul, hr, ← Algebra.smul_def, smul_comm (d : R)] | theorem | RingTheory | [
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Norm.AbsNorm",
"Mathlib.RingTheory.Localization.NormTrace"
] | Mathlib/RingTheory/FractionalIdeal/Norm.lean | absNorm_span_singleton | null |
_root_.IsFractional.map (g : P →ₐ[R] P') {I : Submodule R P} :
IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)
| ⟨a, a_nonzero, hI⟩ =>
⟨a, a_nonzero, fun b hb => by
obtain ⟨b', b'_mem, hb'⟩ := Submodule.mem_map.mp hb
rw [AlgHom.toLinearMap_apply] at hb'
obtain ⟨x, hx⟩ := hI b' b'_mem
use x
rw [← g.commutes, hx, map_smul, hb']⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | _root_.IsFractional.map | null |
map (g : P →ₐ[R] P') : FractionalIdeal S P → FractionalIdeal S P' := fun I =>
⟨Submodule.map g.toLinearMap I, I.isFractional.map g⟩
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map | `I.map g` is the pushforward of the fractional ideal `I` along the algebra morphism `g` |
coe_map (g : P →ₐ[R] P') (I : FractionalIdeal S P) :
↑(map g I) = Submodule.map g.toLinearMap I :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coe_map | null |
mem_map {I : FractionalIdeal S P} {g : P →ₐ[R] P'} {y : P'} :
y ∈ I.map g ↔ ∃ x, x ∈ I ∧ g x = y :=
Submodule.mem_map
variable (I J : FractionalIdeal S P) (g : P →ₐ[R] P')
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mem_map | null |
map_id : I.map (AlgHom.id _ _) = I :=
coeToSubmodule_injective (Submodule.map_id (I : Submodule R P))
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_id | null |
map_comp (g' : P' →ₐ[R] P'') : I.map (g'.comp g) = (I.map g).map g' :=
coeToSubmodule_injective (Submodule.map_comp g.toLinearMap g'.toLinearMap I)
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_comp | null |
map_coeIdeal (I : Ideal R) : (I : FractionalIdeal S P).map g = I := by
ext x
simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_coeIdeal | null |
protected map_one : (1 : FractionalIdeal S P).map g = 1 :=
map_coeIdeal g ⊤
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_one | null |
protected map_zero : (0 : FractionalIdeal S P).map g = 0 :=
map_coeIdeal g 0
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_zero | null |
protected map_add : (I + J).map g = I.map g + J.map g :=
coeToSubmodule_injective (Submodule.map_sup _ _ _)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_add | null |
protected map_mul : (I * J).map g = I.map g * J.map g := by
simp only [mul_def]
exact coeToSubmodule_injective (Submodule.map_mul _ _ _)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_mul | null |
map_map_symm (g : P ≃ₐ[R] P') : (I.map (g : P →ₐ[R] P')).map (g.symm : P' →ₐ[R] P) = I := by
rw [← map_comp, g.symm_comp, map_id]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_map_symm | null |
map_symm_map (I : FractionalIdeal S P') (g : P ≃ₐ[R] P') :
(I.map (g.symm : P' →ₐ[R] P)).map (g : P →ₐ[R] P') = I := by
rw [← map_comp, g.comp_symm, map_id] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_symm_map | null |
map_mem_map {f : P →ₐ[R] P'} (h : Function.Injective f) {x : P} {I : FractionalIdeal S P} :
f x ∈ map f I ↔ x ∈ I :=
mem_map.trans ⟨fun ⟨_, hx', x'_eq⟩ => h x'_eq ▸ hx', fun h => ⟨x, h, rfl⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_mem_map | null |
map_injective (f : P →ₐ[R] P') (h : Function.Injective f) :
Function.Injective (map f : FractionalIdeal S P → FractionalIdeal S P') := fun _ _ hIJ =>
ext fun _ => (map_mem_map h).symm.trans (hIJ.symm ▸ map_mem_map h) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_injective | null |
mapEquiv (g : P ≃ₐ[R] P') : FractionalIdeal S P ≃+* FractionalIdeal S P' where
toFun := map g
invFun := map g.symm
map_add' I J := FractionalIdeal.map_add I J _
map_mul' I J := FractionalIdeal.map_mul I J _
left_inv I := by rw [← map_comp, AlgEquiv.symm_comp, map_id]
right_inv I := by rw [← map_comp, AlgEquiv.comp_symm, map_id]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mapEquiv | If `g` is an equivalence, `map g` is an isomorphism |
coeFun_mapEquiv (g : P ≃ₐ[R] P') :
(mapEquiv g : FractionalIdeal S P → FractionalIdeal S P') = map g :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeFun_mapEquiv | null |
mapEquiv_apply (g : P ≃ₐ[R] P') (I : FractionalIdeal S P) : mapEquiv g I = map (↑g) I :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mapEquiv_apply | null |
mapEquiv_symm (g : P ≃ₐ[R] P') :
((mapEquiv g).symm : FractionalIdeal S P' ≃+* _) = mapEquiv g.symm :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mapEquiv_symm | null |
mapEquiv_refl : mapEquiv AlgEquiv.refl = RingEquiv.refl (FractionalIdeal S P) :=
RingEquiv.ext fun x => by simp | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mapEquiv_refl | null |
isFractional_span_iff {s : Set P} :
IsFractional S (span R s) ↔ ∃ a ∈ S, ∀ b : P, b ∈ s → IsInteger R (a • b) :=
⟨fun ⟨a, a_mem, h⟩ => ⟨a, a_mem, fun b hb => h b (subset_span hb)⟩, fun ⟨a, a_mem, h⟩ =>
⟨a, a_mem, fun _ hb =>
span_induction (hx := hb) h
(by
rw [smul_zero]
exact isInteger_zero)
(fun x y _ _ hx hy => by
rw [smul_add]
exact isInteger_add hx hy)
fun s x _ hx => by
rw [smul_comm]
exact isInteger_smul hx⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isFractional_span_iff | null |
isFractional_of_fg [IsLocalization S P] {I : Submodule R P} (hI : I.FG) :
IsFractional S I := by
rcases hI with ⟨I, rfl⟩
rcases exist_integer_multiples_of_finset S I with ⟨⟨s, hs1⟩, hs⟩
rw [isFractional_span_iff]
exact ⟨s, hs1, hs⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isFractional_of_fg | null |
mem_span_mul_finite_of_mem_mul {I J : FractionalIdeal S P} {x : P} (hx : x ∈ I * J) :
∃ T T' : Finset P, (T : Set P) ⊆ I ∧ (T' : Set P) ⊆ J ∧ x ∈ span R (T * T' : Set P) :=
Submodule.mem_span_mul_finite_of_mem_mul (by simpa using mem_coe.mpr hx)
variable (S) in | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mem_span_mul_finite_of_mem_mul | null |
coeIdeal_fg (inj : Function.Injective (algebraMap R P)) (I : Ideal R) :
FG ((I : FractionalIdeal S P) : Submodule R P) ↔ I.FG :=
coeSubmodule_fg _ inj _ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_fg | null |
fg_unit (I : (FractionalIdeal S P)ˣ) : FG (I : Submodule R P) :=
Submodule.fg_unit <| Units.map (coeSubmoduleHom S P).toMonoidHom I | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | fg_unit | null |
fg_of_isUnit (I : FractionalIdeal S P) (h : IsUnit I) : FG (I : Submodule R P) :=
fg_unit h.unit | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | fg_of_isUnit | null |
_root_.Ideal.fg_of_isUnit (inj : Function.Injective (algebraMap R P)) (I : Ideal R)
(h : IsUnit (I : FractionalIdeal S P)) : I.FG := by
rw [← coeIdeal_fg S inj I]
exact FractionalIdeal.fg_of_isUnit (R := R) I h
variable (S P P')
variable [IsLocalization S P] [IsLocalization S P'] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | _root_.Ideal.fg_of_isUnit | null |
exists_ne_zero_mem_isInteger [Nontrivial R] (hI : I ≠ 0) :
∃ x, x ≠ 0 ∧ algebraMap R K x ∈ I := by
obtain ⟨y : K, y_mem, y_notMem⟩ :=
SetLike.exists_of_lt (by simpa only using bot_lt_iff_ne_bot.mpr hI)
have y_ne_zero : y ≠ 0 := by simpa using y_notMem
obtain ⟨z, ⟨x, hx⟩⟩ := exists_integer_multiple R⁰ y
refine ⟨x, ?_, ?_⟩
· rw [Ne, ← @IsFractionRing.to_map_eq_zero_iff R _ K, hx, Algebra.smul_def]
exact mul_ne_zero (IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors z.2) y_ne_zero
· rw [hx]
exact smul_mem _ _ y_mem | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | exists_ne_zero_mem_isInteger | `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P' :=
mapEquiv
{ ringEquivOfRingEquiv P P' (RingEquiv.refl R)
(show S.map _ = S by rw [RingEquiv.toMonoidHom_refl, Submonoid.map_id]) with
commutes' := fun _ => ringEquivOfRingEquiv_eq _ _ }
@[simp]
theorem mem_canonicalEquiv_apply {I : FractionalIdeal S P} {x : P'} :
x ∈ canonicalEquiv S P P' I ↔
∃ y ∈ I,
IsLocalization.map P' (RingHom.id R) (fun y (hy : y ∈ S) => show RingHom.id R y ∈ S from hy)
(y : P) =
x := by
rw [canonicalEquiv, mapEquiv_apply, mem_map]
exact ⟨fun ⟨y, mem, Eq⟩ => ⟨y, mem, Eq⟩, fun ⟨y, mem, Eq⟩ => ⟨y, mem, Eq⟩⟩
@[simp]
theorem canonicalEquiv_symm : (canonicalEquiv S P P').symm = canonicalEquiv S P' P :=
RingEquiv.ext fun I =>
SetLike.ext_iff.mpr fun x => by
rw [mem_canonicalEquiv_apply, canonicalEquiv, mapEquiv_symm, mapEquiv_apply,
mem_map]
exact ⟨fun ⟨y, mem, Eq⟩ => ⟨y, mem, Eq⟩, fun ⟨y, mem, Eq⟩ => ⟨y, mem, Eq⟩⟩
theorem canonicalEquiv_flip (I) : canonicalEquiv S P P' (canonicalEquiv S P' P I) = I := by
rw [← canonicalEquiv_symm, RingEquiv.symm_apply_apply]
@[simp]
theorem canonicalEquiv_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
[IsLocalization S P''] (I : FractionalIdeal S P) :
canonicalEquiv S P' P'' (canonicalEquiv S P P' I) = canonicalEquiv S P P'' I := by
ext
simp [IsLocalization.map_map]
theorem canonicalEquiv_trans_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
[IsLocalization S P''] :
(canonicalEquiv S P P').trans (canonicalEquiv S P' P'') = canonicalEquiv S P P'' :=
RingEquiv.ext (canonicalEquiv_canonicalEquiv S P P' P'')
@[simp]
theorem canonicalEquiv_coeIdeal (I : Ideal R) : canonicalEquiv S P P' I = I := by
ext
simp [IsLocalization.map_eq]
@[simp]
theorem canonicalEquiv_self : canonicalEquiv S P P = RingEquiv.refl _ := by
rw [← canonicalEquiv_trans_canonicalEquiv S P P]
convert (canonicalEquiv S P P).symm_trans_self
exact (canonicalEquiv_symm S P P).symm
end
section IsFractionRing
/-!
### `IsFractionRing` section
This section concerns fractional ideals in the field of fractions,
i.e. the type `FractionalIdeal R⁰ K` where `IsFractionRing R K`.
-/
variable {K K' : Type*} [Field K] [Field K']
variable [Algebra R K] [IsFractionRing R K] [Algebra R K'] [IsFractionRing R K']
variable {I J : FractionalIdeal R⁰ K} (h : K →ₐ[R] K')
/-- Nonzero fractional ideals contain a nonzero integer. |
map_ne_zero [Nontrivial R] (hI : I ≠ 0) : I.map h ≠ 0 := by
obtain ⟨x, x_ne_zero, hx⟩ := exists_ne_zero_mem_isInteger hI
contrapose! x_ne_zero with map_eq_zero
refine IsFractionRing.to_map_eq_zero_iff.mp (eq_zero_iff.mp map_eq_zero _ (mem_map.mpr ?_))
exact ⟨algebraMap R K x, hx, h.commutes x⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_ne_zero | null |
map_eq_zero_iff [Nontrivial R] : I.map h = 0 ↔ I = 0 :=
⟨not_imp_not.mp (map_ne_zero _), fun hI => hI.symm ▸ FractionalIdeal.map_zero h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_eq_zero_iff | null |
coeIdeal_injective : Function.Injective (fun (I : Ideal R) ↦ (I : FractionalIdeal R⁰ K)) :=
coeIdeal_injective' le_rfl | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_injective | null |
coeIdeal_inj {I J : Ideal R} :
(I : FractionalIdeal R⁰ K) = (J : FractionalIdeal R⁰ K) ↔ I = J :=
coeIdeal_inj' le_rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_inj | null |
coeIdeal_eq_zero {I : Ideal R} : (I : FractionalIdeal R⁰ K) = 0 ↔ I = ⊥ :=
coeIdeal_eq_zero' le_rfl | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_eq_zero | null |
coeIdeal_ne_zero {I : Ideal R} : (I : FractionalIdeal R⁰ K) ≠ 0 ↔ I ≠ ⊥ :=
coeIdeal_ne_zero' le_rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_ne_zero | null |
coeIdeal_eq_one {I : Ideal R} : (I : FractionalIdeal R⁰ K) = 1 ↔ I = 1 := by
simpa only [Ideal.one_eq_top] using coeIdeal_inj | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_eq_one | null |
coeIdeal_ne_one {I : Ideal R} : (I : FractionalIdeal R⁰ K) ≠ 1 ↔ I ≠ 1 :=
not_iff_not.mpr coeIdeal_eq_one | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_ne_one | null |
num_eq_zero_iff [Nontrivial R] {I : FractionalIdeal R⁰ K} : I.num = 0 ↔ I = 0 where
mp h := zero_of_num_eq_bot zero_notMem_nonZeroDivisors h
mpr h := h ▸ num_zero_eq (IsFractionRing.injective R K) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | num_eq_zero_iff | null |
ne_zero_of_mul_eq_one (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) : I ≠ 0 := fun hI =>
zero_ne_one' (FractionalIdeal R₁⁰ K)
(by
convert h
simp [hI])
variable [IsFractionRing R₁ K] [IsDomain R₁] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | ne_zero_of_mul_eq_one | null |
_root_.IsFractional.div_of_nonzero {I J : Submodule R₁ K} :
IsFractional R₁⁰ I → IsFractional R₁⁰ J → J ≠ 0 → IsFractional R₁⁰ (I / J)
| ⟨aI, haI, hI⟩, ⟨aJ, haJ, hJ⟩, h => by
obtain ⟨y, mem_J, notMem_zero⟩ :=
SetLike.exists_of_lt (show 0 < J by simpa only using bot_lt_iff_ne_bot.mpr h)
obtain ⟨y', hy'⟩ := hJ y mem_J
use aI * y'
constructor
· apply (nonZeroDivisors R₁).mul_mem haI (mem_nonZeroDivisors_iff_ne_zero.mpr _)
intro y'_eq_zero
have : algebraMap R₁ K aJ * y = 0 := by
rw [← Algebra.smul_def, ← hy', y'_eq_zero, RingHom.map_zero]
have y_zero :=
(mul_eq_zero.mp this).resolve_left
(mt ((injective_iff_map_eq_zero (algebraMap R₁ K)).1 (IsFractionRing.injective _ _) _)
(mem_nonZeroDivisors_iff_ne_zero.mp haJ))
apply notMem_zero
simpa
intro b hb
convert hI _ (hb _ (Submodule.smul_mem _ aJ mem_J)) using 1
rw [← hy', mul_comm b, ← Algebra.smul_def, mul_smul] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | _root_.IsFractional.div_of_nonzero | null |
fractional_div_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
IsFractional R₁⁰ (I / J : Submodule R₁ K) :=
I.isFractional.div_of_nonzero J.isFractional fun H =>
h <| coeToSubmodule_injective <| H.trans coe_zero.symm
open Classical in | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | fractional_div_of_nonzero | null |
@[simp]
div_zero {I : FractionalIdeal R₁⁰ K} : I / 0 = 0 :=
dif_pos rfl | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | div_zero | null |
div_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
I / J = ⟨I / J, fractional_div_of_nonzero h⟩ :=
dif_neg h
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | div_nonzero | null |
coe_div {I J : FractionalIdeal R₁⁰ K} (hJ : J ≠ 0) :
(↑(I / J) : Submodule R₁ K) = ↑I / (↑J : Submodule R₁ K) :=
congr_arg _ (dif_neg hJ) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coe_div | null |
mem_div_iff_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) {x} :
x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I := by
rw [div_nonzero h]
exact Submodule.mem_div_iff_forall_mul_mem | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mem_div_iff_of_nonzero | null |
mul_one_div_le_one {I : FractionalIdeal R₁⁰ K} : I * (1 / I) ≤ 1 := by
by_cases hI : I = 0
· rw [hI, div_zero, mul_zero]
exact zero_le 1
· rw [← coe_le_coe, coe_mul, coe_div hI, coe_one]
apply Submodule.mul_one_div_le_one | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mul_one_div_le_one | null |
le_self_mul_one_div {I : FractionalIdeal R₁⁰ K} (hI : I ≤ (1 : FractionalIdeal R₁⁰ K)) :
I ≤ I * (1 / I) := by
by_cases hI_nz : I = 0
· rw [hI_nz, div_zero, mul_zero]
· rw [← coe_le_coe, coe_mul, coe_div hI_nz, coe_one]
rw [← coe_le_coe, coe_one] at hI
exact Submodule.le_self_mul_one_div hI | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | le_self_mul_one_div | null |
le_div_iff_of_nonzero {I J J' : FractionalIdeal R₁⁰ K} (hJ' : J' ≠ 0) :
I ≤ J / J' ↔ ∀ x ∈ I, ∀ y ∈ J', x * y ∈ J :=
⟨fun h _ hx => (mem_div_iff_of_nonzero hJ').mp (h hx), fun h x hx =>
(mem_div_iff_of_nonzero hJ').mpr (h x hx)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | le_div_iff_of_nonzero | null |
le_div_iff_mul_le {I J J' : FractionalIdeal R₁⁰ K} (hJ' : J' ≠ 0) :
I ≤ J / J' ↔ I * J' ≤ J := by
rw [div_nonzero hJ', ← coe_le_coe (I := I * J') (J := J), coe_mul]
exact Submodule.le_div_iff_mul_le
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | le_div_iff_mul_le | null |
div_one {I : FractionalIdeal R₁⁰ K} : I / 1 = I := by
rw [div_nonzero (one_ne_zero' (FractionalIdeal R₁⁰ K))]
ext
constructor <;> intro h
· simpa using mem_div_iff_forall_mul_mem.mp h 1 ((algebraMap R₁ K).map_one ▸ coe_mem_one R₁⁰ 1)
· apply mem_div_iff_forall_mul_mem.mpr
rintro y ⟨y', _, rfl⟩
convert Submodule.smul_mem _ y' h using 1
rw [mul_comm, Algebra.linearMap_apply, ← Algebra.smul_def] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | div_one | null |
eq_one_div_of_mul_eq_one_right (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) :
J = 1 / I := by
have hI : I ≠ 0 := ne_zero_of_mul_eq_one I J h
suffices h' : I * (1 / I) = 1 from
congr_arg Units.inv <| @Units.ext _ _ (Units.mkOfMulEqOne _ _ h) (Units.mkOfMulEqOne _ _ h') rfl
apply le_antisymm
· apply mul_le.mpr _
intro x hx y hy
rw [mul_comm]
exact (mem_div_iff_of_nonzero hI).mp hy x hx
rw [← h]
apply mul_left_mono I
apply (le_div_iff_of_nonzero hI).mpr _
intro y hy x hx
rw [mul_comm]
exact mul_mem_mul hy hx | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | eq_one_div_of_mul_eq_one_right | null |
mul_div_self_cancel_iff {I : FractionalIdeal R₁⁰ K} : I * (1 / I) = 1 ↔ ∃ J, I * J = 1 :=
⟨fun h => ⟨1 / I, h⟩, fun ⟨J, hJ⟩ => by rwa [← eq_one_div_of_mul_eq_one_right I J hJ]⟩
variable {K' : Type*} [Field K'] [Algebra R₁ K'] [IsFractionRing R₁ K']
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mul_div_self_cancel_iff | null |
protected map_div (I J : FractionalIdeal R₁⁰ K) (h : K ≃ₐ[R₁] K') :
(I / J).map (h : K →ₐ[R₁] K') = I.map h / J.map h := by
by_cases H : J = 0
· rw [H, div_zero, FractionalIdeal.map_zero, div_zero]
· simp [← coeToSubmodule_inj, div_nonzero H, div_nonzero (map_ne_zero _ H)] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_div | null |
map_one_div (I : FractionalIdeal R₁⁰ K) (h : K ≃ₐ[R₁] K') :
(1 / I).map (h : K →ₐ[R₁] K') = 1 / I.map h := by
rw [FractionalIdeal.map_div, FractionalIdeal.map_one] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | map_one_div | null |
eq_zero_or_one (I : FractionalIdeal K⁰ L) : I = 0 ∨ I = 1 := by
rw [or_iff_not_imp_left]
intro hI
simp_rw [@SetLike.ext_iff _ _ _ I 1, mem_one_iff]
intro x
constructor
· intro x_mem
obtain ⟨n, d, rfl⟩ := IsLocalization.mk'_surjective K⁰ x
refine ⟨n / d, ?_⟩
rw [map_div₀, IsFractionRing.mk'_eq_div]
· rintro ⟨x, rfl⟩
obtain ⟨y, y_ne, y_mem⟩ := exists_ne_zero_mem_isInteger hI
rw [← div_mul_cancel₀ x y_ne, RingHom.map_mul, ← Algebra.smul_def]
exact smul_mem (M := L) I (x / y) y_mem | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | eq_zero_or_one | null |
eq_zero_or_one_of_isField (hF : IsField R₁) (I : FractionalIdeal R₁⁰ K) : I = 0 ∨ I = 1 :=
letI : Field R₁ := hF.toField
eq_zero_or_one I | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | eq_zero_or_one_of_isField | null |
den_mul_self_eq_num' (I : FractionalIdeal S P) :
spanSingleton S (algebraMap R P I.den) * I = I.num := by
apply coeToSubmodule_injective
dsimp only
rw [coe_mul, ← smul_eq_mul, coe_spanSingleton, smul_eq_mul, Submodule.span_singleton_mul]
convert I.den_mul_self_eq_num using 1
ext
rw [mem_smul_pointwise_iff_exists, mem_smul_pointwise_iff_exists]
simp [smul_eq_mul, Algebra.smul_def, Submonoid.smul_def]
variable {S}
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | den_mul_self_eq_num' | `FractionalIdeal.span_finset R₁ s f` is the fractional ideal of `R₁` generated by `f '' s`. -/
-- Porting note: `@[simps]` generated a `Subtype.val` coercion instead of a
-- `FractionalIdeal.coeToSubmodule` coercion
def spanFinset {ι : Type*} (s : Finset ι) (f : ι → K) : FractionalIdeal R₁⁰ K :=
⟨Submodule.span R₁ (f '' s), by
obtain ⟨a', ha'⟩ := IsLocalization.exist_integer_multiples R₁⁰ s f
refine ⟨a', a'.2, fun x hx => Submodule.span_induction ?_ ?_ ?_ ?_ hx⟩
· rintro _ ⟨i, hi, rfl⟩
exact ha' i hi
· rw [smul_zero]
exact IsLocalization.isInteger_zero
· intro x y _ _ hx hy
rw [smul_add]
exact IsLocalization.isInteger_add hx hy
· intro c x _ hx
rw [smul_comm]
exact IsLocalization.isInteger_smul hx⟩
@[simp] lemma spanFinset_coe {ι : Type*} (s : Finset ι) (f : ι → K) :
(spanFinset R₁ s f : Submodule R₁ K) = Submodule.span R₁ (f '' s) :=
rfl
variable {R₁}
@[simp]
theorem spanFinset_eq_zero {ι : Type*} {s : Finset ι} {f : ι → K} :
spanFinset R₁ s f = 0 ↔ ∀ j ∈ s, f j = 0 := by
simp only [← coeToSubmodule_inj, spanFinset_coe, coe_zero, Submodule.span_eq_bot,
Set.mem_image, Finset.mem_coe, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂]
theorem spanFinset_ne_zero {ι : Type*} {s : Finset ι} {f : ι → K} :
spanFinset R₁ s f ≠ 0 ↔ ∃ j ∈ s, f j ≠ 0 := by simp
open Submodule.IsPrincipal
variable [IsLocalization S P]
theorem isFractional_span_singleton (x : P) : IsFractional S (span R {x} : Submodule R P) :=
let ⟨a, ha⟩ := exists_integer_multiple S x
isFractional_span_iff.mpr ⟨a, a.2, fun _ hx' => (Set.mem_singleton_iff.mp hx').symm ▸ ha⟩
variable (S)
/-- `spanSingleton x` is the fractional ideal generated by `x` if `0 ∉ S` -/
irreducible_def spanSingleton (x : P) : FractionalIdeal S P :=
⟨span R {x}, isFractional_span_singleton x⟩
-- local attribute [semireducible] span_singleton
@[simp]
theorem coe_spanSingleton (x : P) : (spanSingleton S x : Submodule R P) = span R {x} := by
rw [spanSingleton]
rfl
@[simp]
theorem mem_spanSingleton {x y : P} : x ∈ spanSingleton S y ↔ ∃ z : R, z • y = x := by
rw [spanSingleton]
exact Submodule.mem_span_singleton
theorem mem_spanSingleton_self (x : P) : x ∈ spanSingleton S x :=
(mem_spanSingleton S).mpr ⟨1, one_smul _ _⟩
variable (P) in
/-- A version of `FractionalIdeal.den_mul_self_eq_num` in terms of fractional ideals. |
spanSingleton_le_iff_mem {x : P} {I : FractionalIdeal S P} :
spanSingleton S x ≤ I ↔ x ∈ I := by
rw [← coe_le_coe, coe_spanSingleton, Submodule.span_singleton_le_iff_mem, mem_coe] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_le_iff_mem | null |
spanSingleton_eq_spanSingleton [NoZeroSMulDivisors R P] {x y : P} :
spanSingleton S x = spanSingleton S y ↔ ∃ z : Rˣ, z • x = y := by
rw [← Submodule.span_singleton_eq_span_singleton, spanSingleton, spanSingleton]
exact Subtype.mk_eq_mk | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_eq_spanSingleton | null |
eq_spanSingleton_of_principal (I : FractionalIdeal S P) [IsPrincipal (I : Submodule R P)] :
I = spanSingleton S (generator (I : Submodule R P)) := by
rw [spanSingleton, ← coeToSubmodule_inj, coe_mk, span_singleton_generator] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | eq_spanSingleton_of_principal | null |
isPrincipal_iff (I : FractionalIdeal S P) :
IsPrincipal (I : Submodule R P) ↔ ∃ x, I = spanSingleton S x :=
⟨fun _ => ⟨generator (I : Submodule R P), eq_spanSingleton_of_principal I⟩,
fun ⟨x, hx⟩ => { principal := ⟨x, Eq.trans (congr_arg _ hx) (coe_spanSingleton _ x)⟩ }⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isPrincipal_iff | null |
spanSingleton_zero : spanSingleton S (0 : P) = 0 := by
ext
simp [eq_comm] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_zero | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.