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 ⌀ |
|---|---|---|---|---|---|---|
map_ne_zero : g.map (IsLocalRing.residue A) ≠ 0 :=
H.map_ne_zero_of_ne_top (Ideal.IsMaximal.ne_top inferInstance) | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | map_ne_zero | null |
degree_eq_coe_lift_order_map : f.degree = (g.map (IsLocalRing.residue A)).order.lift
(order_finite_iff_ne_zero.2 H.map_ne_zero) :=
H.degree_eq_coe_lift_order_map_of_ne_top (Ideal.IsMaximal.ne_top inferInstance) | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | degree_eq_coe_lift_order_map | null |
natDegree_eq_toNat_order_map :
f.natDegree = (g.map (IsLocalRing.residue A)).order.toNat :=
H.natDegree_eq_toNat_order_map_of_ne_top (Ideal.IsMaximal.ne_top inferInstance) | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | natDegree_eq_toNat_order_map | null |
IsWeierstrassDivision.isUnit_of_map_ne_zero
{g q : A⟦X⟧} {r : A[X]} (hg : g.map (IsLocalRing.residue A) ≠ 0)
(H : (X ^ (g.map (IsLocalRing.residue A)).order.toNat).IsWeierstrassDivision g q r) :
IsUnit q := by
obtain ⟨H1 : r.degree < (g.map (IsLocalRing.residue A)).order.toNat, H2⟩ := H
set n := (g.map (IsLocalRing.residue A)).order.toNat
replace H2 := congr(coeff n (($H2).map (IsLocalRing.residue A)))
simp_rw [map_pow, map_X, coeff_X_pow_self, map_add, map_mul, coeff_map,
Polynomial.coeff_coe, Polynomial.coeff_eq_zero_of_degree_lt H1, map_zero, add_zero] at H2
rw [isUnit_iff_constantCoeff, ← isUnit_map_iff (IsLocalRing.residue A)]
rw [coeff_mul, ← Finset.sum_subset (s₁ := {(n, 0)}) (by simp) (fun p hp hnotMem ↦ ?_),
Finset.sum_singleton, coeff_map, coeff_map, coeff_zero_eq_constantCoeff, mul_comm] at H2
· exact isUnit_of_mul_eq_one _ _ H2.symm
· rw [coeff_of_lt_order p.1 ?_]
· rw [zero_mul]
· rw [← ENat.lt_lift_iff (h := order_finite_iff_ne_zero.2 hg), ENat.lift_eq_toNat_of_lt_top]
refine (Finset.antidiagonal.fst_le hp).lt_of_ne ?_
contrapose! hnotMem
rwa [Finset.mem_singleton, Finset.antidiagonal_congr hp (by simp)] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | IsWeierstrassDivision.isUnit_of_map_ne_zero | null |
IsWeierstrassDivision.isWeierstrassFactorization
{g q : A⟦X⟧} {r : A[X]} (hg : g.map (IsLocalRing.residue A) ≠ 0)
(H : (X ^ (g.map (IsLocalRing.residue A)).order.toNat).IsWeierstrassDivision g q r) :
g.IsWeierstrassFactorization
(Polynomial.X ^ (g.map (IsLocalRing.residue A)).order.toNat - r)
↑(H.isUnit_of_map_ne_zero hg).unit⁻¹ := by
have H1 : r.degree < (g.map (IsLocalRing.residue A)).order.toNat := H.1
set n := (g.map (IsLocalRing.residue A)).order.toNat
set f := Polynomial.X ^ n - r
replace H1 : r.degree < (Polynomial.X (R := A) ^ n).degree := by rwa [Polynomial.degree_X_pow]
have hfdeg : f.natDegree = n := by
suffices f.degree = n by rw [Polynomial.natDegree, this]; rfl
rw [Polynomial.degree_sub_eq_left_of_degree_lt H1, Polynomial.degree_X_pow]
refine ⟨⟨⟨fun {i} hi ↦ ?_⟩, .sub_of_left (Polynomial.monic_X_pow _) H1⟩, Units.isUnit _, ?_⟩
· rw [hfdeg] at hi
simp_rw [f, Polynomial.coeff_sub, Polynomial.coeff_X_pow, if_neg hi.ne, zero_sub, neg_mem_iff]
have := H.coeff_f_sub_r_mem hi
rwa [map_sub, coeff_X_pow, if_neg hi.ne, zero_sub, neg_mem_iff, Polynomial.coeff_coe] at this
· have := congr($(H.2) * ↑(H.isUnit_of_map_ne_zero hg).unit⁻¹)
rw [add_mul, mul_assoc, IsUnit.mul_val_inv, mul_one, ← sub_eq_iff_eq_add] at this
simp_rw [← this, f, Polynomial.coe_sub, Polynomial.coe_pow, Polynomial.coe_X, sub_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | IsWeierstrassDivision.isWeierstrassFactorization | null |
IsWeierstrassFactorization.isWeierstrassDivision
{g : A⟦X⟧} {f : A[X]} {h : A⟦X⟧} (H : g.IsWeierstrassFactorization f h) :
(X ^ (g.map (IsLocalRing.residue A)).order.toNat).IsWeierstrassDivision g ↑H.isUnit.unit⁻¹
(Polynomial.X ^ (g.map (IsLocalRing.residue A)).order.toNat - f) := by
set n := (g.map (IsLocalRing.residue A)).order.toNat with hn
constructor
· refine (Polynomial.degree_sub_lt ?_ (Polynomial.monic_X_pow n).ne_zero ?_).trans_eq (by simpa)
· simp_rw [H.degree_eq_coe_lift_order_map, Polynomial.degree_X_pow, n,
ENat.lift_eq_toNat_of_lt_top]
· rw [(Polynomial.monic_X_pow n).leadingCoeff, H.isDistinguishedAt.monic.leadingCoeff]
· simp_rw [H.eq_mul, mul_assoc, IsUnit.mul_val_inv, mul_one, Polynomial.coe_sub,
Polynomial.coe_pow, Polynomial.coe_X, add_sub_cancel] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | IsWeierstrassFactorization.isWeierstrassDivision | null |
IsWeierstrassFactorization.elim [IsHausdorff (IsLocalRing.maximalIdeal A) A]
{g : A⟦X⟧} {f f' : A[X]} {h h' : A⟦X⟧} (H : g.IsWeierstrassFactorization f h)
(H2 : g.IsWeierstrassFactorization f' h') : f = f' ∧ h = h' := by
obtain ⟨h1, h2⟩ := H.isWeierstrassDivision.elim H.map_ne_zero H2.isWeierstrassDivision
rw [← Units.ext_iff, inv_inj, Units.ext_iff] at h1
exact ⟨by simpa using h2, h1⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | IsWeierstrassFactorization.elim | The `f` and `h` in the Weierstrass preparation theorem are unique.
This result is stated using two `PowerSeries.IsWeierstrassFactorization` assertions, and only
requires the ring being Hausdorff with respect to the maximal ideal. If you want `f` and `h` equal
to `PowerSeries.weierstrassDistinguished` and `PowerSeries.weierstrassUnit`,
use `PowerSeries.IsWeierstrassFactorization.unique` instead, which requires the ring being
complete with respect to the maximal ideal. |
exists_isWeierstrassFactorization (hg : g.map (IsLocalRing.residue A) ≠ 0) :
∃ f h, g.IsWeierstrassFactorization f h := by
obtain ⟨q, r, H⟩ :=
(X ^ (g.map (IsLocalRing.residue A)).order.toNat).exists_isWeierstrassDivision hg
exact ⟨_, _, H.isWeierstrassFactorization hg⟩
variable (g) in | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | exists_isWeierstrassFactorization | **Weierstrass preparation theorem** ([washington_cyclotomic], Theorem 7.3):
let `g` be a power series over a complete local ring,
such that its image in the residue field is not zero. Then there exists a distinguished
polynomial `f` and a power series `h` which is a unit, such that `g = f * h`. |
noncomputable weierstrassDistinguished (hg : g.map (IsLocalRing.residue A) ≠ 0) : A[X] :=
(g.exists_isWeierstrassFactorization hg).choose
variable (g) in | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassDistinguished | The `f` in the Weierstrass preparation theorem. |
noncomputable weierstrassUnit (hg : g.map (IsLocalRing.residue A) ≠ 0) : A⟦X⟧ :=
(g.exists_isWeierstrassFactorization hg).choose_spec.choose | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassUnit | The `h` in the Weierstrass preparation theorem. |
isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(hg : g.map (IsLocalRing.residue A) ≠ 0) :
g.IsWeierstrassFactorization (g.weierstrassDistinguished hg) (g.weierstrassUnit hg) :=
(g.exists_isWeierstrassFactorization hg).choose_spec.choose_spec | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit | null |
noncomputable algEquivQuotientWeierstrassDistinguished
(hg : g.map (IsLocalRing.residue A) ≠ 0) :=
(g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg).algEquivQuotient | abbrev | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | algEquivQuotientWeierstrassDistinguished | If `g` is a power series over a complete local ring,
such that its image in the residue field is not zero, then there is a natural isomorphism
`A[X] / (f) ≃ₐ[A] A⟦X⟧ / (g)` where `f` is `PowerSeries.weierstrassDistinguished g`. |
isDistinguishedAt_weierstrassDistinguished (hg : g.map (IsLocalRing.residue A) ≠ 0) :
(g.weierstrassDistinguished hg).IsDistinguishedAt (IsLocalRing.maximalIdeal A) :=
(g.exists_isWeierstrassFactorization hg).choose_spec.choose_spec.isDistinguishedAt | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | isDistinguishedAt_weierstrassDistinguished | null |
isUnit_weierstrassUnit (hg : g.map (IsLocalRing.residue A) ≠ 0) :
IsUnit (g.weierstrassUnit hg) :=
(g.exists_isWeierstrassFactorization hg).choose_spec.choose_spec.isUnit | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | isUnit_weierstrassUnit | null |
eq_weierstrassDistinguished_mul_weierstrassUnit (hg : g.map (IsLocalRing.residue A) ≠ 0) :
g = g.weierstrassDistinguished hg * g.weierstrassUnit hg :=
(g.exists_isWeierstrassFactorization hg).choose_spec.choose_spec.eq_mul | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | eq_weierstrassDistinguished_mul_weierstrassUnit | null |
IsWeierstrassFactorization.unique
(H : g.IsWeierstrassFactorization f h) (hg : g.map (IsLocalRing.residue A) ≠ 0) :
f = g.weierstrassDistinguished hg ∧ h = g.weierstrassUnit hg :=
H.elim (g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | IsWeierstrassFactorization.unique | The `f` and `h` in Weierstrass preparation theorem are equal
to `PowerSeries.weierstrassDistinguished` and `PowerSeries.weierstrassUnit`. |
weierstrassDistinguished_mul (hg : (g * g').map (IsLocalRing.residue A) ≠ 0) :
(g * g').weierstrassDistinguished hg =
g.weierstrassDistinguished (fun h ↦ hg (by simp [h])) *
g'.weierstrassDistinguished (fun h ↦ hg (by simp [h])) := by
have H := g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [h]))
have H' := g'.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [h]))
have H'' := (g * g').isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg
exact (H''.elim (H.mul H')).1
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassDistinguished_mul | null |
weierstrassUnit_mul (hg : (g * g').map (IsLocalRing.residue A) ≠ 0) :
(g * g').weierstrassUnit hg =
g.weierstrassUnit (fun h ↦ hg (by simp [h])) *
g'.weierstrassUnit (fun h ↦ hg (by simp [h])) := by
have H := g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [h]))
have H' := g'.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [h]))
have H'' := (g * g').isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg
exact (H''.elim (H.mul H')).2
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassUnit_mul | null |
weierstrassDistinguished_smul (hg : (a • g).map (IsLocalRing.residue A) ≠ 0) :
(a • g).weierstrassDistinguished hg =
g.weierstrassDistinguished (fun h ↦ hg (by simp [Algebra.smul_def, h])) := by
have H := g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [Algebra.smul_def, h]))
have H' := (a • g).isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg
have ha : IsLocalRing.residue A a ≠ 0 := fun h ↦ hg (by simp [Algebra.smul_def, h])
exact (H'.elim (H.smul (by simpa using ha))).1
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassDistinguished_smul | null |
weierstrassUnit_smul (hg : (a • g).map (IsLocalRing.residue A) ≠ 0) :
(a • g).weierstrassUnit hg =
a • g.weierstrassUnit (fun h ↦ hg (by simp [Algebra.smul_def, h])) := by
have H := g.isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit
(fun h ↦ hg (by simp [Algebra.smul_def, h]))
have H' := (a • g).isWeierstrassFactorization_weierstrassDistinguished_weierstrassUnit hg
have ha : IsLocalRing.residue A a ≠ 0 := fun h ↦ hg (by simp [Algebra.smul_def, h])
exact (H'.elim (H.smul (by simpa using ha))).2 | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished",
"Mathlib.RingTheory.PowerSeries.CoeffMulMem",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.PowerSeries.Trunc"
] | Mathlib/RingTheory/PowerSeries/WeierstrassPreparation.lean | weierstrassUnit_smul | null |
invUnitsSub (u : Rˣ) : PowerSeries R :=
mk fun n => 1 /ₚ u ^ (n + 1)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invUnitsSub | The power series for `1 / (u - x)`. |
coeff_invUnitsSub (u : Rˣ) (n : ℕ) : coeff n (invUnitsSub u) = 1 /ₚ u ^ (n + 1) :=
coeff_mk _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | coeff_invUnitsSub | null |
constantCoeff_invUnitsSub (u : Rˣ) : constantCoeff (invUnitsSub u) = 1 /ₚ u := by
rw [← coeff_zero_eq_constantCoeff_apply, coeff_invUnitsSub, zero_add, pow_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | constantCoeff_invUnitsSub | null |
invUnitsSub_mul_X (u : Rˣ) : invUnitsSub u * X = invUnitsSub u * C (u : R) - 1 := by
ext (_ | n)
· simp
· simp [pow_succ']
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invUnitsSub_mul_X | null |
invUnitsSub_mul_sub (u : Rˣ) : invUnitsSub u * (C (u : R) - X) = 1 := by
simp [mul_sub, sub_sub_cancel] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invUnitsSub_mul_sub | null |
map_invUnitsSub (f : R →+* S) (u : Rˣ) :
map f (invUnitsSub u) = invUnitsSub (Units.map (f : R →* S) u) := by
ext
simp only [← map_pow, coeff_map, coeff_invUnitsSub, one_divp]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | map_invUnitsSub | null |
mk_one_mul_one_sub_eq_one : (mk 1 : S⟦X⟧) * (1 - X) = 1 := by
rw [mul_comm, PowerSeries.ext_iff]
intro n
cases n with
| zero => simp
| succ n => simp [sub_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | mk_one_mul_one_sub_eq_one | (1 + X + X^2 + ...) * (1 - X) = 1.
Note that the power series `1 + X + X^2 + ...` is written as `mk 1` where `1` is the constant
function so that `mk 1` is the power series with all coefficients equal to one. |
mk_one_pow_eq_mk_choose_add :
(mk 1 : S⟦X⟧) ^ (d + 1) = (mk fun n => Nat.choose (d + n) d : S⟦X⟧) := by
induction d with
| zero => ext; simp
| succ d hd =>
ext n
rw [pow_add, hd, pow_one, mul_comm, coeff_mul]
simp_rw [coeff_mk, Pi.one_apply, one_mul]
norm_cast
rw [Finset.sum_antidiagonal_choose_add, add_right_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | mk_one_pow_eq_mk_choose_add | Note that `mk 1` is the constant function `1` so the power series `1 + X + X^2 + ...`. This theorem
states that for any `d : ℕ`, `(1 + X + X^2 + ... : S⟦X⟧) ^ (d + 1)` is equal to the power series
`mk fun n => Nat.choose (d + n) d : S⟦X⟧`. |
noncomputable invOneSubPow : ℕ → S⟦X⟧ˣ
| 0 => 1
| d + 1 => {
val := mk fun n => Nat.choose (d + n) d
inv := (1 - X) ^ (d + 1)
val_inv := by
rw [← mk_one_pow_eq_mk_choose_add, ← mul_pow, mk_one_mul_one_sub_eq_one, one_pow]
inv_val := by
rw [← mk_one_pow_eq_mk_choose_add, ← mul_pow, mul_comm, mk_one_mul_one_sub_eq_one, one_pow]
} | def | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow | Given a natural number `d : ℕ` and a commutative ring `S`, `PowerSeries.invOneSubPow S d` is the
multiplicative inverse of `(1 - X) ^ d` in `S⟦X⟧ˣ`. When `d` is `0`, `PowerSeries.invOneSubPow S d`
will just be `1`. When `d` is positive, `PowerSeries.invOneSubPow S d` will be the power series
`mk fun n => Nat.choose (d - 1 + n) (d - 1)`. |
invOneSubPow_zero : invOneSubPow S 0 = 1 := by
delta invOneSubPow
simp only | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_zero | null |
invOneSubPow_val_eq_mk_sub_one_add_choose_of_pos (h : 0 < d) :
(invOneSubPow S d).val = (mk fun n => Nat.choose (d - 1 + n) (d - 1) : S⟦X⟧) := by
rw [← Nat.sub_one_add_one_eq_of_pos h, invOneSubPow, add_tsub_cancel_right] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_val_eq_mk_sub_one_add_choose_of_pos | null |
invOneSubPow_val_succ_eq_mk_add_choose :
(invOneSubPow S (d + 1)).val = (mk fun n => Nat.choose (d + n) d : S⟦X⟧) := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_val_succ_eq_mk_add_choose | null |
invOneSubPow_val_one_eq_invUnitSub_one :
(invOneSubPow S 1).val = invUnitsSub (1 : Sˣ) := by
simp [invOneSubPow, invUnitsSub] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_val_one_eq_invUnitSub_one | null |
invOneSubPow_eq_inv_one_sub_pow :
invOneSubPow S d =
(Units.mkOfMulEqOne (1 - X) (mk 1 : S⟦X⟧) <|
Eq.trans (mul_comm _ _) (mk_one_mul_one_sub_eq_one S))⁻¹ ^ d := by
induction d with
| zero => exact Eq.symm <| pow_zero _
| succ d _ =>
rw [inv_pow]
exact (DivisionMonoid.inv_eq_of_mul _ (invOneSubPow S (d + 1)) <| by
rw [← Units.val_eq_one, Units.val_mul, Units.val_pow_eq_pow_val]
exact (invOneSubPow S (d + 1)).inv_val).symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_eq_inv_one_sub_pow | The theorem `PowerSeries.mk_one_mul_one_sub_eq_one` implies that `1 - X` is a unit in `S⟦X⟧`
whose inverse is the power series `1 + X + X^2 + ...`. This theorem states that for any `d : ℕ`,
`PowerSeries.invOneSubPow S d` is equal to `(1 - X)⁻¹ ^ d`. |
invOneSubPow_inv_eq_one_sub_pow :
(invOneSubPow S d).inv = (1 - X : S⟦X⟧) ^ d := by
induction d with
| zero => exact Eq.symm <| pow_zero _
| succ d => rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_inv_eq_one_sub_pow | null |
invOneSubPow_inv_zero_eq_one : (invOneSubPow S 0).inv = 1 := by
delta invOneSubPow
simp only [Units.inv_eq_val_inv, inv_one, Units.val_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_inv_zero_eq_one | null |
mk_add_choose_mul_one_sub_pow_eq_one :
(mk fun n ↦ Nat.choose (d + n) d : S⟦X⟧) * ((1 - X) ^ (d + 1)) = 1 :=
(invOneSubPow S (d + 1)).val_inv | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | mk_add_choose_mul_one_sub_pow_eq_one | null |
invOneSubPow_add (e : ℕ) :
invOneSubPow S (d + e) = invOneSubPow S d * invOneSubPow S e := by
simp_rw [invOneSubPow_eq_inv_one_sub_pow, pow_add] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | invOneSubPow_add | null |
one_sub_pow_mul_invOneSubPow_val_add_eq_invOneSubPow_val (e : ℕ) :
(1 - X) ^ e * (invOneSubPow S (d + e)).val = (invOneSubPow S d).val := by
simp [invOneSubPow_add, Units.val_mul, mul_comm, mul_assoc, ← invOneSubPow_inv_eq_one_sub_pow] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | one_sub_pow_mul_invOneSubPow_val_add_eq_invOneSubPow_val | null |
one_sub_pow_add_mul_invOneSubPow_val_eq_one_sub_pow (e : ℕ) :
(1 - X) ^ (d + e) * (invOneSubPow S e).val = (1 - X) ^ d := by
simp [pow_add, mul_assoc, ← invOneSubPow_inv_eq_one_sub_pow S e] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | one_sub_pow_add_mul_invOneSubPow_val_eq_one_sub_pow | null |
exp : PowerSeries A :=
mk fun n => algebraMap ℚ A (1 / n !) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | exp | Power series for the exponential function at zero. |
sin : PowerSeries A :=
mk fun n => if Even n then 0 else algebraMap ℚ A ((-1) ^ (n / 2) / n !) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | sin | Power series for the sine function at zero. |
cos : PowerSeries A :=
mk fun n => if Even n then algebraMap ℚ A ((-1) ^ (n / 2) / n !) else 0
variable {A A'} (n : ℕ)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | cos | Power series for the cosine function at zero. |
coeff_exp : coeff n (exp A) = algebraMap ℚ A (1 / n !) :=
coeff_mk _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | coeff_exp | null |
constantCoeff_exp : constantCoeff (exp A) = 1 := by
rw [← coeff_zero_eq_constantCoeff_apply, coeff_exp]
simp
variable (f : A →+* A')
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | constantCoeff_exp | null |
map_exp : map (f : A →+* A') (exp A) = exp A' := by
ext
simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | map_exp | null |
map_sin : map f (sin A) = sin A' := by
ext
simp [sin, apply_ite f]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | map_sin | null |
map_cos : map f (cos A) = cos A' := by
ext
simp [cos, apply_ite f] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | map_cos | null |
exp_mul_exp_eq_exp_add [Algebra ℚ A] (a b : A) :
rescale a (exp A) * rescale b (exp A) = rescale (a + b) (exp A) := by
ext n
simp only [coeff_mul, exp, rescale, coeff_mk, MonoidHom.coe_mk, OneHom.coe_mk, coe_mk,
Nat.sum_antidiagonal_eq_sum_range_succ_mk, add_pow, sum_mul]
apply sum_congr rfl
rintro x hx
suffices
a ^ x * b ^ (n - x) *
(algebraMap ℚ A (1 / ↑x.factorial) * algebraMap ℚ A (1 / ↑(n - x).factorial)) =
a ^ x * b ^ (n - x) * (↑(n.choose x) * (algebraMap ℚ A) (1 / ↑n.factorial))
by convert this using 1 <;> ring
congr 1
rw [← map_natCast (algebraMap ℚ A) (n.choose x), ← map_mul, ← map_mul]
refine RingHom.congr_arg _ ?_
rw [mul_one_div (↑(n.choose x) : ℚ), one_div_mul_one_div]
symm
rw [div_eq_iff, div_mul_eq_mul_div, one_mul, choose_eq_factorial_div_factorial]
· norm_cast
rw [cast_div_charZero]
apply factorial_mul_factorial_dvd_factorial (mem_range_succ_iff.1 hx)
· apply mem_range_succ_iff.1 hx
· rintro h
apply factorial_ne_zero n
rw [cast_eq_zero.1 h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | exp_mul_exp_eq_exp_add | Shows that $e^{aX} * e^{bX} = e^{(a + b)X}$ |
exp_mul_exp_neg_eq_one [Algebra ℚ A] : exp A * evalNegHom (exp A) = 1 := by
convert exp_mul_exp_eq_exp_add (1 : A) (-1) <;> simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | exp_mul_exp_neg_eq_one | Shows that $e^{x} * e^{-x} = 1$ |
exp_pow_eq_rescale_exp [Algebra ℚ A] (k : ℕ) : exp A ^ k = rescale (k : A) (exp A) := by
induction k with
| zero =>
simp only [rescale_zero, constantCoeff_exp, Function.comp_apply, map_one, cast_zero,
pow_zero (exp A), coe_comp]
| succ k h =>
simpa only [succ_eq_add_one, cast_add, ← exp_mul_exp_eq_exp_add (k : A), ← h, cast_one,
id_apply, rescale_one] using pow_succ (exp A) k | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | exp_pow_eq_rescale_exp | Shows that $(e^{X})^k = e^{kX}$. |
exp_pow_sum [Algebra ℚ A] (n : ℕ) :
((Finset.range n).sum fun k => exp A ^ k) =
PowerSeries.mk fun p => (Finset.range n).sum
fun k => (k ^ p : A) * algebraMap ℚ A p.factorial⁻¹ := by
simp only [exp_pow_eq_rescale_exp, rescale]
ext
simp only [one_div, coeff_mk, coe_mk, MonoidHom.coe_mk, OneHom.coe_mk,
coeff_exp, map_sum] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/WellKnown.lean | exp_pow_sum | Shows that
$\sum_{k = 0}^{n - 1} (e^{X})^k = \sum_{p = 0}^{\infty} \sum_{k = 0}^{n - 1} \frac{k^p}{p!}X^p$. |
LinearMap.exact_smul_id_smul_top_mkQ (M : Type v) [AddCommGroup M] [Module R M] (r : R) :
Function.Exact (r • LinearMap.id : M →ₗ[R] M) (r • (⊤ : Submodule R M)).mkQ := by
intro x
simp [Submodule.mem_smul_pointwise_iff_exists,
Submodule.mem_smul_pointwise_iff_exists] | lemma | RingTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/Category.lean | LinearMap.exact_smul_id_smul_top_mkQ | null |
@[simps]
smulShortComplex (r : R) :
ShortComplex (ModuleCat R) where
X₁ := M
X₂ := M
X₃ := ModuleCat.of R (QuotSMulTop r M)
f := ModuleCat.ofHom (r • LinearMap.id)
g := ModuleCat.ofHom (r • (⊤ : Submodule R M)).mkQ
zero := by
ext x
exact (LinearMap.exact_smul_id_smul_top_mkQ M r).apply_apply_eq_zero x | def | RingTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/Category.lean | smulShortComplex | The short (exact) complex `M → M → M⧸xM` obtain from the scalar multiple of `x : R` on `M`. |
smulShortComplex_exact (r : R) : (smulShortComplex M r).Exact := by
simp [smulShortComplex, ShortComplex.ShortExact.moduleCat_exact_iff_function_exact,
LinearMap.exact_smul_id_smul_top_mkQ] | lemma | RingTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/Category.lean | smulShortComplex_exact | null |
smulShortComplex_g_epi (r : R) : Epi (smulShortComplex M r).g := by
simpa [smulShortComplex, ModuleCat.epi_iff_surjective] using Submodule.mkQ_surjective _ | instance | RingTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/Category.lean | smulShortComplex_g_epi | null |
IsSMulRegular.smulShortComplex_shortExact {r : R} (reg : IsSMulRegular M r) :
(ModuleCat.smulShortComplex M r).ShortExact where
exact := ModuleCat.smulShortComplex_exact M r
mono_f := by simpa [ModuleCat.smulShortComplex, ModuleCat.mono_iff_injective] using reg | lemma | RingTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/Category.lean | IsSMulRegular.smulShortComplex_shortExact | null |
linearMap_subsingleton_of_mem_annihilator {r : R} (reg : IsSMulRegular M r)
(mem_ann : r ∈ Module.annihilator R N) : Subsingleton (N →ₗ[R] M) := by
apply subsingleton_of_forall_eq 0 (fun f ↦ ext fun x ↦ ?_)
have : r • (f x) = r • 0 := by
rw [smul_zero, ← map_smul, Module.mem_annihilator.mp mem_ann x, map_zero]
simpa using reg this | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Finiteness",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Localization",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Regular.IsSMulRegular",
"Mathlib.RingTh... | Mathlib/RingTheory/Regular/Depth.lean | linearMap_subsingleton_of_mem_annihilator | null |
subsingleton_linearMap_iff [IsNoetherianRing R] [Module.Finite R M] [Module.Finite R N] :
Subsingleton (N →ₗ[R] M) ↔ ∃ r ∈ Module.annihilator R N, IsSMulRegular M r := by
refine ⟨fun hom0 ↦ ?_, fun ⟨r, mem_ann, reg⟩ ↦
linearMap_subsingleton_of_mem_annihilator reg mem_ann⟩
by_cases htrivial : Subsingleton M
· exact ⟨0, ⟨Submodule.zero_mem (Module.annihilator R N), IsSMulRegular.zero⟩⟩
· push_neg at htrivial
by_contra! h
have hexist : ∃ p ∈ associatedPrimes R M, Module.annihilator R N ≤ p := by
rcases associatedPrimes.nonempty R M with ⟨Ia, hIa⟩
apply (Ideal.subset_union_prime_finite (associatedPrimes.finite R M) Ia Ia _).mp
· rw [biUnion_associatedPrimes_eq_compl_regular R M]
exact fun r hr ↦ h r hr
· exact fun I hin _ _ ↦ IsAssociatedPrime.isPrime hin
rcases hexist with ⟨p, pass, hp⟩
let _ := pass.isPrime
let p' : PrimeSpectrum R := ⟨p, pass.isPrime⟩
have loc_ne_zero : p' ∈ Module.support R N := Module.mem_support_iff_of_finite.mpr hp
rw [Module.mem_support_iff] at loc_ne_zero
let Rₚ := Localization.AtPrime p
let Nₚ := LocalizedModule p'.asIdeal.primeCompl N
let Mₚ := LocalizedModule p'.asIdeal.primeCompl M
let Nₚ' := Nₚ ⧸ (IsLocalRing.maximalIdeal (Localization.AtPrime p)) • (⊤ : Submodule Rₚ Nₚ)
have ntr : Nontrivial Nₚ' :=
Submodule.Quotient.nontrivial_of_lt_top _ (Ne.lt_top'
(Submodule.top_ne_ideal_smul_of_le_jacobson_annihilator
(IsLocalRing.maximalIdeal_le_jacobson (Module.annihilator Rₚ Nₚ))))
let Mₚ' := Mₚ ⧸ (IsLocalRing.maximalIdeal (Localization.AtPrime p)) • (⊤ : Submodule Rₚ Mₚ)
let _ : Module p.ResidueField Nₚ' :=
Module.instQuotientIdealSubmoduleHSMulTop Nₚ (maximalIdeal (Localization.AtPrime p))
have := AssociatePrimes.mem_iff.mp
(associatedPrimes.mem_associatePrimes_localizedModule_atPrime_of_mem_associated_primes pass)
rcases this.2 with ⟨x, hx⟩
have : Nontrivial (Module.Dual p.ResidueField Nₚ') := by simpa using ntr
rcases exists_ne (α := Module.Dual p.ResidueField Nₚ') 0 with ⟨g, hg⟩
let to_res' : Nₚ' →ₗ[Rₚ] p.ResidueField := {
__ := g
map_smul' r x := by
simp only [AddHom.toFun_eq_coe, coe_toAddHom, RingHom.id_apply]
convert g.map_smul (Ideal.Quotient.mk _ r) x }
let to_res : Nₚ →ₗ[Rₚ] p.ResidueField :=
to_res'.comp ((maximalIdeal (Localization.AtPrime p)) • (⊤ : Submodule Rₚ Nₚ)).mkQ
let i : p.ResidueField →ₗ[Rₚ] Mₚ :=
Submodule.liftQ _ (LinearMap.toSpanSingleton Rₚ Mₚ x) (le_of_eq hx)
have inj1 : Function.Injective i :=
LinearMap.ker_eq_bot.mp (Submodule.ker_liftQ_eq_bot _ _ _ (le_of_eq hx.symm))
let f := i.comp to_res
have f_ne0 : f ≠ 0 := by
intro eq0
absurd hg
apply LinearMap.ext
... | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Finiteness",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Localization",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Regular.IsSMulRegular",
"Mathlib.RingTh... | Mathlib/RingTheory/Regular/Depth.lean | subsingleton_linearMap_iff | null |
IsWeaklyRegular.of_flat_of_isBaseChange [Flat R S] {f : M →ₗ[R] N} (hf : IsBaseChange S f)
{rs : List R} (reg : IsWeaklyRegular M rs) : IsWeaklyRegular N (rs.map (algebraMap R S)) := by
induction rs generalizing M N with
| nil => simp
| cons x _ ih =>
simp only [List.map_cons, isWeaklyRegular_cons_iff] at reg ⊢
have e := (QuotSMulTop.algebraMapTensorEquivTensorQuotSMulTop x M S).symm ≪≫ₗ
QuotSMulTop.congr ((algebraMap R S) x) hf.equiv
have hg : IsBaseChange S <|
e.toLinearMap.restrictScalars R ∘ₗ TensorProduct.mk R S (QuotSMulTop x M) 1 :=
IsBaseChange.of_equiv e (fun _ ↦ by simp)
exact ⟨reg.1.of_flat_of_isBaseChange hf, ih hg reg.2⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.of_flat_of_isBaseChange | Let `R` be a commutative ring, `M` be an `R`-module, `S` be a flat `R`-algebra, `N` be the base
change of `M` to `S`. If `[r₁, …, rₙ]` is a weakly regular `M`-sequence, then its image in `N` is
a weakly regular `N`-sequence. |
IsWeaklyRegular.of_flat [Flat R S] {rs : List R} (reg : IsWeaklyRegular R rs) :
IsWeaklyRegular S (rs.map (algebraMap R S)) :=
reg.of_flat_of_isBaseChange (IsBaseChange.linearMap R S)
variable (S) (T : Submonoid R) [IsLocalization T S] | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.of_flat | null |
IsWeaklyRegular.of_isLocalizedModule (f : M →ₗ[R] N) [IsLocalizedModule T f]
{rs : List R} (reg : IsWeaklyRegular M rs) : IsWeaklyRegular N (rs.map (algebraMap R S)) :=
have : Flat R S := IsLocalization.flat S T
reg.of_flat_of_isBaseChange (IsLocalizedModule.isBaseChange T S f)
include T in | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.of_isLocalizedModule | null |
IsWeaklyRegular.of_isLocalization {rs : List R} (reg : IsWeaklyRegular R rs) :
IsWeaklyRegular S (rs.map (algebraMap R S)) :=
reg.of_isLocalizedModule S T (Algebra.linearMap R S)
variable (p : Ideal R) [p.IsPrime] [IsLocalization.AtPrime S p] | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.of_isLocalization | null |
IsWeaklyRegular.isRegular_of_isLocalizedModule_of_mem
[Nontrivial N] [Module.Finite S N] (f : M →ₗ[R] N) [IsLocalizedModule.AtPrime p f]
{rs : List R} (reg : IsWeaklyRegular M rs) (mem : ∀ r ∈ rs, r ∈ p) :
IsRegular N (rs.map (algebraMap R S)) := by
have : IsLocalRing S := IsLocalization.AtPrime.isLocalRing S p
refine (IsLocalRing.isRegular_iff_isWeaklyRegular_of_subset_maximalIdeal (fun _ hr ↦ ?_)).mpr <|
reg.of_isLocalizedModule S p.primeCompl f
rcases List.mem_map.mp hr with ⟨r, hr, eq⟩
simpa only [← eq, IsLocalization.AtPrime.to_map_mem_maximal_iff S p] using mem r hr | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.isRegular_of_isLocalizedModule_of_mem | null |
IsWeaklyRegular.isRegular_of_isLocalization_of_mem
{rs : List R} (reg : IsWeaklyRegular R rs) (mem : ∀ r ∈ rs, r ∈ p) :
IsRegular S (rs.map (algebraMap R S)) :=
have : Nontrivial S := IsLocalization.AtPrime.nontrivial S p
reg.isRegular_of_isLocalizedModule_of_mem S p (Algebra.linearMap R S) mem
variable {S} [FaithfullyFlat R S] | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsWeaklyRegular.isRegular_of_isLocalization_of_mem | null |
IsRegular.of_faithfullyFlat_of_isBaseChange {f : M →ₗ[R] N} (hf : IsBaseChange S f)
{rs : List R} (reg : IsRegular M rs) : IsRegular N (rs.map (algebraMap R S)) := by
refine ⟨reg.1.of_flat_of_isBaseChange hf, ?_⟩
rw [← Ideal.map_ofList]
exact ((hf.map_smul_top_ne_top_iff_of_faithfullyFlat R M _).mpr reg.2.symm).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsRegular.of_faithfullyFlat_of_isBaseChange | Let `R` be a commutative ring, `M` be an `R`-module, `S` be a faithfully flat `R`-algebra,
`N` be the base change of `M` to `S`. If `[r₁, …, rₙ]` is a regular `M`-sequence, then its image
in `N` is a regular `N`-sequence. |
IsRegular.of_faithfullyFlat {rs : List R} (reg : IsRegular R rs) :
IsRegular S (rs.map (algebraMap R S)) :=
reg.of_faithfullyFlat_of_isBaseChange (IsBaseChange.linearMap R S) | theorem | RingTheory | [
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Regular.RegularSequence"
] | Mathlib/RingTheory/Regular/Flat.lean | IsRegular.of_faithfullyFlat | null |
LinearEquiv.isSMulRegular_congr' [AddCommMonoid N] [Module S N]
(e : M ≃ₛₗ[σ] N) (r : R) : IsSMulRegular M r ↔ IsSMulRegular N (σ r) :=
e.toEquiv.isSMulRegular_congr (e.map_smul' r) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | LinearEquiv.isSMulRegular_congr' | null |
LinearEquiv.isSMulRegular_congr [AddCommMonoid N] [Module R N]
(e : M ≃ₗ[R] N) (r : R) : IsSMulRegular M r ↔ IsSMulRegular N r :=
e.isSMulRegular_congr' r | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | LinearEquiv.isSMulRegular_congr | null |
IsSMulRegular.submodule [Semiring R] [AddCommMonoid M] [Module R M]
(N : Submodule R M) (r : R) (h : IsSMulRegular M r) : IsSMulRegular N r :=
h.of_injective N.subtype N.injective_subtype | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | IsSMulRegular.submodule | null |
IsSMulRegular.lTensor : IsSMulRegular (M ⊗[R] M') r :=
have h1 := congrArg DFunLike.coe (LinearMap.lTensor_smul_action M M' r)
h1.subst (Module.Flat.lTensor_preserves_injective_linearMap _ h) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | IsSMulRegular.lTensor | null |
IsSMulRegular.rTensor : IsSMulRegular (M' ⊗[R] M) r :=
have h1 := congrArg DFunLike.coe (LinearMap.rTensor_smul_action M M' r)
h1.subst (Module.Flat.rTensor_preserves_injective_linearMap _ h) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | IsSMulRegular.rTensor | null |
isSMulRegular_algebraMap_iff [CommSemiring R] [Semiring S] [Algebra R S]
[AddCommMonoid M] [Module R M] [Module S M] [IsScalarTower R S M] (r : R) :
IsSMulRegular M (algebraMap R S r) ↔ IsSMulRegular M r :=
(Equiv.refl M).isSMulRegular_congr (algebraMap_smul S r) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_algebraMap_iff | null |
isSMulRegular_submodule_iff_right_eq_zero_of_smul :
IsSMulRegular N r ↔ ∀ x ∈ N, r • x = 0 → x = 0 :=
isSMulRegular_iff_right_eq_zero_of_smul.trans <|
Subtype.forall.trans <| by
simp only [SetLike.mk_smul_mk, Submodule.mk_eq_zero] | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_submodule_iff_right_eq_zero_of_smul | null |
isSMulRegular_quotient_iff_mem_of_smul_mem :
IsSMulRegular (M ⧸ N) r ↔ ∀ x : M, r • x ∈ N → x ∈ N :=
isSMulRegular_iff_right_eq_zero_of_smul.trans <|
N.mkQ_surjective.forall.trans <| by
simp_rw [← map_smul, N.mkQ_apply, Submodule.Quotient.mk_eq_zero]
variable {N r} | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_quotient_iff_mem_of_smul_mem | null |
mem_of_isSMulRegular_quotient_of_smul_mem (h1 : IsSMulRegular (M ⧸ N) r)
{x : M} (h2 : r • x ∈ N) : x ∈ N :=
(isSMulRegular_quotient_iff_mem_of_smul_mem N r).mp h1 x h2
@[deprecated (since := "2025-08-04")]
alias isSMulRegular_on_submodule_iff_mem_imp_smul_eq_zero_imp_eq_zero :=
isSMulRegular_submodule_iff_right_eq_zero_of_smul
@[deprecated (since := "2025-08-04")]
alias isSMulRegular_on_quot_iff_smul_mem_implies_mem := isSMulRegular_quotient_iff_mem_of_smul_mem
@[deprecated (since := "2025-08-04")]
alias mem_of_isSMulRegular_on_quot_of_smul_mem := mem_of_isSMulRegular_quotient_of_smul_mem | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | mem_of_isSMulRegular_quotient_of_smul_mem | null |
isSMulRegular_of_range_eq_ker {f : M →ₗ[R] M'} {g : M' →ₗ[R] M''}
(hf : Function.Injective f) (hfg : LinearMap.range f = LinearMap.ker g)
(h1 : IsSMulRegular M r) (h2 : IsSMulRegular M'' r) :
IsSMulRegular M' r := by
refine IsSMulRegular.of_right_eq_zero_of_smul ?_
intro x hx
obtain ⟨y, ⟨⟩⟩ := (congrArg (x ∈ ·) hfg).mpr <| h2.right_eq_zero_of_smul <|
(g.map_smul r x).symm.trans <| (congrArg _ hx).trans g.map_zero
refine (congrArg f (h1.right_eq_zero_of_smul ?_)).trans f.map_zero
exact hf <| (f.map_smul r y).trans <| hx.trans f.map_zero.symm | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_of_range_eq_ker | Given a left exact sequence `0 → M → M' → M''`, if `r` is regular on both
`M` and `M''` it's regular `M'` too. |
isSMulRegular_of_isSMulRegular_on_submodule_on_quotient
(h1 : IsSMulRegular N r) (h2 : IsSMulRegular (M ⧸ N) r) : IsSMulRegular M r :=
isSMulRegular_of_range_eq_ker N.injective_subtype
(N.range_subtype.trans N.ker_mkQ.symm) h1 h2 | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_of_isSMulRegular_on_submodule_on_quotient | null |
biUnion_associatedPrimes_eq_compl_regular [IsNoetherianRing R] :
⋃ p ∈ associatedPrimes R M, p = { r : R | IsSMulRegular M r }ᶜ :=
Eq.trans (biUnion_associatedPrimes_eq_zero_divisors R M) <| by
simp_rw [Set.compl_setOf, isSMulRegular_iff_right_eq_zero_of_smul,
not_forall, exists_prop, and_comm] | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | biUnion_associatedPrimes_eq_compl_regular | null |
isSMulRegular_iff_ker_lsmul_eq_bot :
IsSMulRegular M r ↔ LinearMap.ker (LinearMap.lsmul R M r) = ⊥ :=
isSMulRegular_iff_torsionBy_eq_bot M r
variable {M} | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_iff_ker_lsmul_eq_bot | null |
isSMulRegular_on_submodule_iff_disjoint_ker_lsmul_submodule :
IsSMulRegular N r ↔ Disjoint (LinearMap.ker (LinearMap.lsmul R M r)) N :=
Iff.trans (isSMulRegular_submodule_iff_right_eq_zero_of_smul N r) <|
Iff.symm <| Iff.trans disjoint_comm disjoint_def | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_on_submodule_iff_disjoint_ker_lsmul_submodule | null |
isSMulRegular_on_quot_iff_lsmul_comap_le :
IsSMulRegular (M ⧸ N) r ↔ N.comap (LinearMap.lsmul R M r) ≤ N :=
isSMulRegular_quotient_iff_mem_of_smul_mem N r | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_on_quot_iff_lsmul_comap_le | null |
isSMulRegular_on_quot_iff_lsmul_comap_eq :
IsSMulRegular (M ⧸ N) r ↔ N.comap (LinearMap.lsmul R M r) = N :=
Iff.trans (isSMulRegular_on_quot_iff_lsmul_comap_le N r) <|
LE.le.ge_iff_eq' (fun _ => N.smul_mem r)
variable {r} | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_on_quot_iff_lsmul_comap_eq | null |
IsSMulRegular.isSMulRegular_on_quot_iff_smul_top_inf_eq_smul :
IsSMulRegular M r → (IsSMulRegular (M ⧸ N) r ↔ r • ⊤ ⊓ N ≤ r • N) := by
intro (h : Function.Injective (DistribMulAction.toLinearMap R M r))
rw [isSMulRegular_on_quot_iff_lsmul_comap_le, ← map_le_map_iff_of_injective h,
← LinearMap.lsmul_eq_DistribMulAction_toLinearMap,
map_comap_eq, LinearMap.range_eq_map]; rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | IsSMulRegular.isSMulRegular_on_quot_iff_smul_top_inf_eq_smul | null |
isSMulRegular_of_ker_lsmul_eq_bot
(h : LinearMap.ker (LinearMap.lsmul R M r) = ⊥) :
IsSMulRegular M r :=
(isSMulRegular_iff_ker_lsmul_eq_bot M r).mpr h
variable {N} in | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | isSMulRegular_of_ker_lsmul_eq_bot | null |
smul_top_inf_eq_smul_of_isSMulRegular_on_quot :
IsSMulRegular (M ⧸ N) r → r • ⊤ ⊓ N ≤ r • N := by
convert map_mono ∘ (isSMulRegular_on_quot_iff_lsmul_comap_le N r).mp using 2
exact Eq.trans (congrArg (· ⊓ N) (map_top _)) (map_comap_eq _ _).symm
open Function in | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | smul_top_inf_eq_smul_of_isSMulRegular_on_quot | null |
QuotSMulTop.map_first_exact_on_four_term_exact_of_isSMulRegular_last
{M'''} [AddCommGroup M'''] [Module R M''']
{r : R} {f₁ : M →ₗ[R] M'} {f₂ : M' →ₗ[R] M''} {f₃ : M'' →ₗ[R] M'''}
(h₁₂ : Exact f₁ f₂) (h₂₃ : Exact f₂ f₃) (h : IsSMulRegular M''' r) :
Exact (map r f₁) (map r f₂) :=
suffices IsSMulRegular (M'' ⧸ LinearMap.range f₂) r by
dsimp [map, mapQLinear]
rw [Exact.exact_mapQ_iff h₁₂, map_pointwise_smul, Submodule.map_top, inf_comm]
exact smul_top_inf_eq_smul_of_isSMulRegular_on_quot this
h.of_injective _ <| LinearMap.ker_eq_bot.mp <|
ker_liftQ_eq_bot' _ _ h₂₃.linearMap_ker_eq.symm | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.QuotSMulTop"
] | Mathlib/RingTheory/Regular/IsSMulRegular.lean | QuotSMulTop.map_first_exact_on_four_term_exact_of_isSMulRegular_last | null |
ofList (rs : List R) := span { r | r ∈ rs }
@[simp] lemma ofList_nil : (ofList [] : Ideal R) = ⊥ :=
have : { r | r ∈ [] } = ∅ := Set.eq_empty_of_forall_notMem (fun _ => List.not_mem_nil)
Eq.trans (congrArg span this) span_empty
@[simp] lemma ofList_append (rs₁ rs₂ : List R) :
ofList (rs₁ ++ rs₂) = ofList rs₁ ⊔ ofList rs₂ :=
have : { r | r ∈ rs₁ ++ rs₂ } = _ := Set.ext (fun _ => List.mem_append)
Eq.trans (congrArg span this) (span_union _ _) | abbrev | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | ofList | The ideal generated by a list of elements. |
ofList_singleton (r : R) : ofList [r] = span {r} :=
congrArg span (Set.ext fun _ => List.mem_singleton)
@[simp] lemma ofList_cons (r : R) (rs : List R) :
ofList (r::rs) = span {r} ⊔ ofList rs :=
Eq.trans (ofList_append [r] rs) (congrArg (· ⊔ _) (ofList_singleton r))
@[simp] lemma map_ofList (f : R →+* S) (rs : List R) :
map f (ofList rs) = ofList (rs.map f) :=
Eq.trans (map_span f { r | r ∈ rs }) <| congrArg span <|
Set.ext (fun _ => List.mem_map.symm) | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | ofList_singleton | null |
ofList_cons_smul {R} [CommSemiring R] (r : R) (rs : List R) {M}
[AddCommMonoid M] [Module R M] (N : Submodule R M) :
ofList (r :: rs) • N = r • N ⊔ ofList rs • N := by
rw [ofList_cons, Submodule.sup_smul, Submodule.ideal_span_singleton_smul] | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | ofList_cons_smul | null |
smul_top_le_comap_smul_top [Semiring R] [AddCommMonoid M]
[AddCommMonoid M₂] [Module R M] [Module R M₂] (I : Ideal R)
(f : M →ₗ[R] M₂) : I • ⊤ ≤ comap f (I • ⊤) :=
map_le_iff_le_comap.mp <| le_of_eq_of_le (map_smul'' _ _ _) <|
smul_mono_right _ le_top
variable (M) [CommRing R] [AddCommGroup M] [AddCommGroup M₂]
[Module R M] [Module R M₂] (r : R) (rs : List R) | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | smul_top_le_comap_smul_top | null |
quotOfListConsSMulTopEquivQuotSMulTopInner :
(M ⧸ (Ideal.ofList (r :: rs) • ⊤ : Submodule R M)) ≃ₗ[R]
QuotSMulTop r M ⧸ (Ideal.ofList rs • ⊤ : Submodule R (QuotSMulTop r M)) :=
quotEquivOfEq _ _ (Ideal.ofList_cons_smul r rs ⊤) ≪≫ₗ
(quotientQuotientEquivQuotientSup (r • ⊤) (Ideal.ofList rs • ⊤)).symm ≪≫ₗ
quotEquivOfEq _ _ (by rw [map_smul'', map_top, range_mkQ]) | def | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | quotOfListConsSMulTopEquivQuotSMulTopInner | The equivalence between M ⧸ (r₀, r₁, …, rₙ)M and (M ⧸ r₀M) ⧸ (r₁, …, rₙ) (M ⧸ r₀M). |
quotOfListConsSMulTopEquivQuotSMulTopOuter :
(M ⧸ (Ideal.ofList (r :: rs) • ⊤ : Submodule R M)) ≃ₗ[R]
QuotSMulTop r (M ⧸ (Ideal.ofList rs • ⊤ : Submodule R M)) :=
quotEquivOfEq _ _ (Eq.trans (Ideal.ofList_cons_smul r rs ⊤) (sup_comm _ _)) ≪≫ₗ
(quotientQuotientEquivQuotientSup (Ideal.ofList rs • ⊤) (r • ⊤)).symm ≪≫ₗ
quotEquivOfEq _ _ (by rw [map_pointwise_smul, map_top, range_mkQ])
variable {M} | def | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | quotOfListConsSMulTopEquivQuotSMulTopOuter | The equivalence between M ⧸ (r₀, r₁, …, rₙ)M and (M ⧸ (r₁, …, rₙ)) ⧸ r₀ (M ⧸ (r₁, …, rₙ)). |
quotOfListConsSMulTopEquivQuotSMulTopInner_naturality (f : M →ₗ[R] M₂) :
(quotOfListConsSMulTopEquivQuotSMulTopInner M₂ r rs).toLinearMap ∘ₗ
mapQ _ _ _ (smul_top_le_comap_smul_top (Ideal.ofList (r :: rs)) f) =
mapQ _ _ _ (smul_top_le_comap_smul_top _ (QuotSMulTop.map r f)) ∘ₗ
(quotOfListConsSMulTopEquivQuotSMulTopInner M r rs).toLinearMap :=
quot_hom_ext _ _ _ fun _ => rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | quotOfListConsSMulTopEquivQuotSMulTopInner_naturality | null |
top_eq_ofList_cons_smul_iff :
(⊤ : Submodule R M) = Ideal.ofList (r :: rs) • ⊤ ↔
(⊤ : Submodule R (QuotSMulTop r M)) = Ideal.ofList rs • ⊤ := by
conv => congr <;> rw [eq_comm, ← subsingleton_quotient_iff_eq_top]
exact (quotOfListConsSMulTopEquivQuotSMulTopInner M r rs).toEquiv.subsingleton_congr | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | top_eq_ofList_cons_smul_iff | null |
@[mk_iff]
IsWeaklyRegular (rs : List R) : Prop where
regular_mod_prev : ∀ i (h : i < rs.length),
IsSMulRegular (M ⧸ (ofList (rs.take i) • ⊤ : Submodule R M)) rs[i] | structure | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | IsWeaklyRegular | A sequence `[r₁, …, rₙ]` is weakly regular on `M` iff `rᵢ` is regular on
`M⧸(r₁, …, rᵢ₋₁)M` for all `1 ≤ i ≤ n`. |
isWeaklyRegular_iff_Fin (rs : List R) :
IsWeaklyRegular M rs ↔ ∀ (i : Fin rs.length),
IsSMulRegular (M ⧸ (ofList (rs.take i) • ⊤ : Submodule R M)) rs[i] :=
Iff.trans (isWeaklyRegular_iff M rs) (Iff.symm Fin.forall_iff) | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | isWeaklyRegular_iff_Fin | null |
@[mk_iff]
IsRegular (rs : List R) : Prop extends IsWeaklyRegular M rs where
top_ne_smul : (⊤ : Submodule R M) ≠ Ideal.ofList rs • ⊤ | structure | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | IsRegular | A weakly regular sequence `rs` on `M` is regular if also `M/rsM ≠ 0`. |
private _root_.AddHom.map_smul_top_toAddSubgroup_of_surjective
{f : M →+ M₂} {as : List R} {bs : List S} (hf : Function.Surjective f)
(h : List.Forall₂ (fun r s => ∀ x, f (r • x) = s • f x) as bs) :
(Ideal.ofList as • ⊤ : Submodule R M).toAddSubgroup.map f =
(Ideal.ofList bs • ⊤ : Submodule S M₂).toAddSubgroup := by
induction h with
| nil =>
convert AddSubgroup.map_bot f using 1 <;>
rw [Ideal.ofList_nil, bot_smul, bot_toAddSubgroup]
| @cons r s _ _ h _ ih =>
conv => congr <;> rw [Ideal.ofList_cons, sup_smul, sup_toAddSubgroup,
ideal_span_singleton_smul, pointwise_smul_toAddSubgroup,
top_toAddSubgroup, pointwise_smul_def]
apply DFunLike.ext (f.comp (toAddMonoidEnd R M r))
((toAddMonoidEnd S M₂ s).comp f) at h
rw [AddSubgroup.map_sup, ih, map_map, h, ← map_map,
map_top_of_surjective f hf] | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | _root_.AddHom.map_smul_top_toAddSubgroup_of_surjective | null |
_root_.AddEquiv.isWeaklyRegular_congr {e : M ≃+ M₂} {as bs}
(h : List.Forall₂ (fun (r : R) (s : S) => ∀ x, e (r • x) = s • e x) as bs) :
IsWeaklyRegular M as ↔ IsWeaklyRegular M₂ bs := by
conv => congr <;> rw [isWeaklyRegular_iff_Fin]
let e' i : (M ⧸ (Ideal.ofList (as.take i) • ⊤ : Submodule R M)) ≃+
M₂ ⧸ (Ideal.ofList (bs.take i) • ⊤ : Submodule S M₂) :=
QuotientAddGroup.congr _ _ e <|
AddHom.map_smul_top_toAddSubgroup_of_surjective e.surjective <|
List.forall₂_take i h
refine (finCongr h.length_eq).forall_congr @fun _ => (e' _).isSMulRegular_congr ?_
exact (mkQ_surjective _).forall.mpr fun _ => congrArg (mkQ _) (h.get _ _ _) | lemma | RingTheory | [
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Nakayama",
"Mathlib.RingTheory.Regular.IsSMulRegular"
] | Mathlib/RingTheory/Regular/RegularSequence.lean | _root_.AddEquiv.isWeaklyRegular_congr | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.