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_algebraMap_eq_subst_X (f : R⟦X⟧) :
map (algebraMap R S) f = subst X f :=
MvPowerSeries.map_algebraMap_eq_subst_X f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | map_algebraMap_eq_subst_X | null |
_root_.Polynomial.toPowerSeries_toMvPowerSeries (p : Polynomial R) :
(p : PowerSeries R) =
((Polynomial.aeval (MvPolynomial.X ()) p : MvPolynomial Unit R) : MvPowerSeries Unit R) := by
suffices (Polynomial.coeToPowerSeries.algHom R) p =
(MvPolynomial.coeToMvPowerSeries.algHom R)
(Polynomial.aeval (MvPolynomial.X () : MvPolynomial Unit R) p) by simpa
rw [← AlgHom.comp_apply]
apply AlgHom.congr_fun
apply Polynomial.algHom_ext
simp [X] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | _root_.Polynomial.toPowerSeries_toMvPowerSeries | null |
substAlgHom_coe (ha : HasSubst a) (p : Polynomial R) :
substAlgHom ha (p : PowerSeries R) = ↑(Polynomial.aeval a p) := by
rw [p.toPowerSeries_toMvPowerSeries, substAlgHom, MvPowerSeries.coe_substAlgHom,
MvPowerSeries.subst_coe, ← AlgHom.comp_apply]
apply AlgHom.congr_fun
apply Polynomial.algHom_ext
simp | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom_coe | null |
substAlgHom_X (ha : HasSubst a) :
substAlgHom ha (X : R⟦X⟧) = a := by
rw [← Polynomial.coe_X, substAlgHom_coe, Polynomial.aeval_X] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom_X | null |
subst_coe (ha : HasSubst a) (p : Polynomial R) :
subst a (p : PowerSeries R) = (Polynomial.aeval a p) := by
rw [← coe_substAlgHom ha, substAlgHom_coe] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_coe | null |
subst_X (ha : HasSubst a) :
subst a (X : R⟦X⟧) = a := by
rw [← coe_substAlgHom ha, substAlgHom_X] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_X | null |
HasSubst.comp
{a : PowerSeries S} (ha : HasSubst a) {b : MvPowerSeries υ T} (hb : HasSubst b) :
HasSubst (substAlgHom hb a) :=
MvPowerSeries.IsNilpotent_subst hb.const ha
variable {a : PowerSeries S} {b : MvPowerSeries υ T} {a' : MvPowerSeries τ S}
{b' : τ → MvPowerSeries υ T} [IsScalarTower R S T] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.comp | null |
substAlgHom_comp_substAlgHom (ha : HasSubst a) (hb : HasSubst b) :
((substAlgHom hb).restrictScalars R).comp (substAlgHom ha)
= substAlgHom (ha.comp hb) :=
MvPowerSeries.substAlgHom_comp_substAlgHom _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom_comp_substAlgHom | null |
substAlgHom_comp_substAlgHom_apply (ha : HasSubst a) (hb : HasSubst b) (f : PowerSeries R) :
(substAlgHom hb) (substAlgHom ha f) = substAlgHom (ha.comp hb) f :=
DFunLike.congr_fun (substAlgHom_comp_substAlgHom ha hb) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom_comp_substAlgHom_apply | null |
subst_comp_subst (ha : HasSubst a) (hb : HasSubst b) :
(subst b) ∘ (subst a) = subst (R := R) (subst b a) := by
simpa [funext_iff, DFunLike.ext_iff, coe_substAlgHom] using substAlgHom_comp_substAlgHom ha hb | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_comp_subst | null |
subst_comp_subst_apply (ha : HasSubst a) (hb : HasSubst b) (f : PowerSeries R) :
subst b (subst a f) = subst (subst b a) f :=
congr_fun (subst_comp_subst ha hb) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_comp_subst_apply | null |
_root_.MvPowerSeries.rescaleUnit (a : R) (f : R⟦X⟧) :
MvPowerSeries.rescale (Function.const _ a) f = rescale a f := by
ext d
rw [coeff_rescale, coeff, MvPowerSeries.coeff_rescale]
simp | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | _root_.MvPowerSeries.rescaleUnit | null |
trunc (n : ℕ) (φ : R⟦X⟧) : R[X] :=
∑ m ∈ Ico 0 n, Polynomial.monomial m (coeff m φ) | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc | The `n`th truncation of a formal power series to a polynomial |
coeff_trunc (m) (n) (φ : R⟦X⟧) :
(trunc n φ).coeff m = if m < n then coeff m φ else 0 := by
simp [trunc, Polynomial.coeff_monomial]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | coeff_trunc | null |
trunc_zero (n) : trunc n (0 : R⟦X⟧) = 0 :=
Polynomial.ext fun m => by
rw [coeff_trunc, LinearMap.map_zero, Polynomial.coeff_zero]
split_ifs <;> rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_zero | null |
trunc_one (n) : trunc (n + 1) (1 : R⟦X⟧) = 1 :=
Polynomial.ext fun m => by
grind [PowerSeries.coeff_trunc, PowerSeries.coeff_one, Polynomial.coeff_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_one | null |
trunc_C (n) (a : R) : trunc (n + 1) (C a) = Polynomial.C a :=
Polynomial.ext fun m => by
rw [coeff_trunc, coeff_C, Polynomial.coeff_C]
split_ifs with H <;> first | rfl | try simp_all
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_C | null |
trunc_add (n) (φ ψ : R⟦X⟧) : trunc n (φ + ψ) = trunc n φ + trunc n ψ :=
Polynomial.ext fun m => by
simp only [coeff_trunc, Polynomial.coeff_add]
split_ifs with H
· rfl
· rw [zero_add] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_add | null |
trunc_succ (f : R⟦X⟧) (n : ℕ) :
trunc n.succ f = trunc n f + Polynomial.monomial n (coeff n f) := by
rw [trunc, Ico_zero_eq_range, sum_range_succ, trunc, Ico_zero_eq_range] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_succ | null |
natDegree_trunc_lt (f : R⟦X⟧) (n) : (trunc (n + 1) f).natDegree < n + 1 := by
rw [Nat.lt_succ_iff, natDegree_le_iff_coeff_eq_zero]
intros
rw [coeff_trunc]
split_ifs with h
· rw [lt_succ, ← not_lt] at h
contradiction
· rfl
@[simp] lemma trunc_zero' {f : R⟦X⟧} : trunc 0 f = 0 := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | natDegree_trunc_lt | null |
degree_trunc_lt (f : R⟦X⟧) (n) : (trunc n f).degree < n := by
rw [degree_lt_iff_coeff_zero]
intros
rw [coeff_trunc]
split_ifs with h
· rw [← not_le] at h
contradiction
· rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | degree_trunc_lt | null |
eval₂_trunc_eq_sum_range {S : Type*} [Semiring S] (s : S) (G : R →+* S) (n) (f : R⟦X⟧) :
(trunc n f).eval₂ G s = ∑ i ∈ range n, G (coeff i f) * s ^ i := by
cases n with
| zero =>
rw [trunc_zero', range_zero, sum_empty, eval₂_zero]
| succ n =>
have := natDegree_trunc_lt f n
rw [eval₂_eq_sum_range' (hn := this)]
apply sum_congr rfl
intro _ h
rw [mem_range] at h
congr
rw [coeff_trunc, if_pos h]
@[simp] theorem trunc_X (n) : trunc (n + 2) X = (Polynomial.X : R[X]) := by
ext d
rw [coeff_trunc, coeff_X]
split_ifs with h₁ h₂
· rw [h₂, coeff_X_one]
· rw [coeff_X_of_ne_one h₂]
· rw [coeff_X_of_ne_one]
intro hd
apply h₁
rw [hd]
exact n.one_lt_succ_succ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | eval₂_trunc_eq_sum_range | null |
trunc_X_of {n : ℕ} (hn : 2 ≤ n) : trunc n X = (Polynomial.X : R[X]) := by
cases n with
| zero => contradiction
| succ n =>
cases n with
| zero => contradiction
| succ n => exact trunc_X n
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_X_of | null |
trunc_one_left (p : R⟦X⟧) : trunc (R := R) 1 p = .C (coeff 0 p) := by
ext i; simp +contextual [coeff_trunc, Polynomial.coeff_C] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_one_left | null |
trunc_one_X : trunc (R := R) 1 X = 0 := by simp
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_one_X | null |
trunc_C_mul (n : ℕ) (r : R) (f : R⟦X⟧) : trunc n (C r * f) = .C r * trunc n f := by
ext i; simp [coeff_trunc]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_C_mul | null |
trunc_mul_C (n : ℕ) (f : R⟦X⟧) (r : R) : trunc n (f * C r) = trunc n f * .C r := by
ext i; simp [coeff_trunc] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_mul_C | null |
eq_shift_mul_X_pow_add_trunc (n : ℕ) (f : R⟦X⟧) :
f = (mk fun i ↦ coeff (i + n) f) * X ^ n + (f.trunc n : R⟦X⟧) := by
ext j
rw [map_add, Polynomial.coeff_coe, coeff_mul_X_pow', coeff_trunc]
simp_rw [← not_le]
split_ifs with h <;> simp [h] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | eq_shift_mul_X_pow_add_trunc | Split off the first `n` coefficients. |
eq_X_pow_mul_shift_add_trunc (n : ℕ) (f : R⟦X⟧) :
f = X ^ n * (mk fun i ↦ coeff (i + n) f) + (f.trunc n : R⟦X⟧) := by
rw [← (commute_X_pow _ n).eq, ← eq_shift_mul_X_pow_add_trunc] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | eq_X_pow_mul_shift_add_trunc | Split off the first `n` coefficients. |
trunc_trunc_of_le {n m} (f : R⟦X⟧) (hnm : n ≤ m := by rfl) :
trunc n ↑(trunc m f) = trunc n f := by
ext d
rw [coeff_trunc, coeff_trunc, coeff_coe]
split_ifs with h
· rw [coeff_trunc, if_pos <| lt_of_lt_of_le h hnm]
· rfl
@[simp] theorem trunc_trunc {n} (f : R⟦X⟧) : trunc n ↑(trunc n f) = trunc n f :=
trunc_trunc_of_le f
@[simp] theorem trunc_trunc_mul {n} (f g : R⟦X⟧) :
trunc n ((trunc n f) * g : R⟦X⟧) = trunc n (f * g) := by
ext m
rw [coeff_trunc, coeff_trunc]
split_ifs with h
· rw [coeff_mul, coeff_mul, sum_congr rfl]
intro _ hab
have ha := lt_of_le_of_lt (antidiagonal.fst_le hab) h
rw [coeff_coe, coeff_trunc, if_pos ha]
· rfl
@[simp] theorem trunc_mul_trunc {n} (f g : R⟦X⟧) :
trunc n (f * (trunc n g) : R⟦X⟧) = trunc n (f * g) := by
rw [mul_comm, trunc_trunc_mul, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_trunc_of_le | null |
trunc_trunc_mul_trunc {n} (f g : R⟦X⟧) :
trunc n (trunc n f * trunc n g : R⟦X⟧) = trunc n (f * g) := by
rw [trunc_trunc_mul, trunc_mul_trunc]
@[simp] theorem trunc_trunc_pow (f : R⟦X⟧) (n a : ℕ) :
trunc n ((trunc n f : R⟦X⟧) ^ a) = trunc n (f ^ a) := by
induction a with
| zero =>
rw [pow_zero, pow_zero]
| succ a ih =>
rw [_root_.pow_succ', _root_.pow_succ', trunc_trunc_mul,
← trunc_trunc_mul_trunc, ih, trunc_trunc_mul_trunc] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_trunc_mul_trunc | null |
trunc_coe_eq_self {n} {f : R[X]} (hn : natDegree f < n) : trunc n (f : R⟦X⟧) = f := by
rw [← Polynomial.coe_inj]
ext m
rw [coeff_coe, coeff_trunc]
split
case isTrue h => rfl
case isFalse h =>
rw [not_lt] at h
rw [coeff_coe]; symm
exact coeff_eq_zero_of_natDegree_lt <| lt_of_lt_of_le hn h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_coe_eq_self | null |
coeff_coe_trunc_of_lt {n m} {f : R⟦X⟧} (h : n < m) :
coeff n (trunc m f) = coeff n f := by
rwa [coeff_coe, coeff_trunc, if_pos] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | coeff_coe_trunc_of_lt | The function `coeff n : R⟦X⟧ → R` is continuous. I.e. `coeff n f` depends only on a sufficiently
long truncation of the power series `f`. |
coeff_mul_eq_coeff_trunc_mul_trunc₂ {n a b} (f g : R⟦X⟧) (ha : n < a) (hb : n < b) :
coeff n (f * g) = coeff n ((trunc a f : R⟦X⟧) * (trunc b g : R⟦X⟧)) := by
symm
rw [← coeff_coe_trunc_of_lt n.lt_succ_self, ← trunc_trunc_mul_trunc, trunc_trunc_of_le f ha,
trunc_trunc_of_le g hb, trunc_trunc_mul_trunc, coeff_coe_trunc_of_lt n.lt_succ_self] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | coeff_mul_eq_coeff_trunc_mul_trunc₂ | The `n`-th coefficient of `f*g` may be calculated
from the truncations of `f` and `g`. |
coeff_mul_eq_coeff_trunc_mul_trunc {d n} (f g) (h : d < n) :
coeff d (f * g) = coeff d ((trunc n f : R⟦X⟧) * (trunc n g : R⟦X⟧)) :=
coeff_mul_eq_coeff_trunc_mul_trunc₂ f g h h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | coeff_mul_eq_coeff_trunc_mul_trunc | null |
trunc_map (p : R⟦X⟧) (n : ℕ) : (p.map f).trunc n = (p.trunc n).map f := by
ext m; simp [coeff_trunc, apply_ite f] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Coeff",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Trunc.lean | trunc_map | null |
@[mk_iff]
IsWeierstrassDivisionAt : Prop where
degree_lt : r.degree < (g.map (Ideal.Quotient.mk I)).order.toNat
eq_mul_add : f = g * q + r | structure | 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 | IsWeierstrassDivisionAt | Let `f`, `g` be power series over `A`, `I` be an ideal of `A`,
`PowerSeries.IsWeierstrassDivisionAt f g q r I` is a `Prop` which asserts that a power series
`q` and a polynomial `r` of degree `< n` satisfy `f = g * q + r`, where `n` is the order of the
image of `g` in `(A / I)⟦X⟧` (defined to be zero if such image is zero, in which case
it's mathematically not considered). |
IsWeierstrassDivision [IsLocalRing A] : Prop :=
f.IsWeierstrassDivisionAt g q r (IsLocalRing.maximalIdeal A) | 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 | IsWeierstrassDivision | Version of `PowerSeries.IsWeierstrassDivisionAt` for local rings with respect to
its maximal ideal. |
isWeierstrassDivisionAt_zero : IsWeierstrassDivisionAt 0 g 0 0 I := by
constructor
· rw [Polynomial.degree_zero]
exact WithBot.bot_lt_coe _
· simp
variable {f g q r I} | 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 | isWeierstrassDivisionAt_zero | null |
coeff_f_sub_r_mem (H : f.IsWeierstrassDivisionAt g q r I)
{i : ℕ} (hi : i < (g.map (Ideal.Quotient.mk I)).order.toNat) :
coeff i (f - r : A⟦X⟧) ∈ I := by
replace H := H.2
rw [← sub_eq_iff_eq_add] at H
rw [H]
refine coeff_mul_mem_ideal_of_coeff_left_mem_ideal i (fun j hj ↦ ?_) i le_rfl
have := coeff_of_lt_order_toNat _ (lt_of_le_of_lt hj hi)
rwa [coeff_map, ← RingHom.mem_ker, Ideal.mk_ker] at this | 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 | coeff_f_sub_r_mem | null |
add {f' q' r'} (H : f.IsWeierstrassDivisionAt g q r I)
(H' : f'.IsWeierstrassDivisionAt g q' r' I) :
(f + f').IsWeierstrassDivisionAt g (q + q') (r + r') I :=
⟨(Polynomial.degree_add_le _ _).trans_lt (sup_lt_iff.2 ⟨H.degree_lt, H'.degree_lt⟩), by
rw [H.eq_mul_add, H'.eq_mul_add, Polynomial.coe_add]; ring⟩ | 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 | add | null |
smul (H : f.IsWeierstrassDivisionAt g q r I) (a : A) :
(a • f).IsWeierstrassDivisionAt g (a • q) (a • r) I :=
⟨(Polynomial.degree_smul_le a _).trans_lt H.degree_lt, by
simp [H.eq_mul_add, Algebra.smul_def, mul_add, mul_left_comm]⟩ | 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 | smul | null |
IsWeierstrassDivisorAt : Prop :=
IsUnit (coeff (g.map (Ideal.Quotient.mk I)).order.toNat g) | 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 | IsWeierstrassDivisorAt | `PowerSeries.IsWeierstrassDivisorAt g I` is a `Prop` which asserts that the `n`-th coefficient
of `g` is a unit, where `n` is the order of the
image of `g` in `(A / I)⟦X⟧` (defined to be zero if such image is zero, in which case
it's mathematically not considered).
This property guarantees that if the ring is `I`-adic complete, then `g` can be used as a divisor
in Weierstrass division (`PowerSeries.IsWeierstrassDivisorAt.isWeierstrassDivisionAt_div_mod`). |
IsWeierstrassDivisor [IsLocalRing A] : Prop :=
g.IsWeierstrassDivisorAt (IsLocalRing.maximalIdeal A)
variable {g} in | 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 | IsWeierstrassDivisor | Version of `PowerSeries.IsWeierstrassDivisorAt` for local rings with respect to
its maximal ideal. |
IsWeierstrassDivisor.of_map_ne_zero [IsLocalRing A]
(hg : g.map (IsLocalRing.residue A) ≠ 0) : g.IsWeierstrassDivisor := by
rw [IsWeierstrassDivisor, IsWeierstrassDivisorAt, ← IsLocalRing.notMem_maximalIdeal]
have h := coeff_order hg
contrapose! h
rwa [coeff_map, IsLocalRing.residue_eq_zero_iff] | 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 | IsWeierstrassDivisor.of_map_ne_zero | If `g` is a power series over a local ring such that
its image in the residue field is not zero, then `g` can be used as a Weierstrass divisor. |
_root_.Polynomial.IsDistinguishedAt.isWeierstrassDivisorAt {g : A[X]} {I : Ideal A}
(H : g.IsDistinguishedAt I) (hI : I ≠ ⊤) : IsWeierstrassDivisorAt g I := by
have : g.natDegree = _ := congr(ENat.toNat $(H.coe_natDegree_eq_order_map g 1
(by rwa [constantCoeff_one, ← Ideal.ne_top_iff_one]) (by simp)))
simp [IsWeierstrassDivisorAt, ← this, H.monic.leadingCoeff] | 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 | _root_.Polynomial.IsDistinguishedAt.isWeierstrassDivisorAt | null |
_root_.Polynomial.IsDistinguishedAt.isWeierstrassDivisorAt' {g : A[X]} {I : Ideal A}
(H : g.IsDistinguishedAt I) [IsHausdorff I A] : IsWeierstrassDivisorAt g I := by
rcases eq_or_ne I ⊤ with rfl | hI
· have := ‹IsHausdorff ⊤ A›.subsingleton
exact isUnit_of_subsingleton _
exact H.isWeierstrassDivisorAt hI | 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 | _root_.Polynomial.IsDistinguishedAt.isWeierstrassDivisorAt' | null |
private coeff_trunc_order_mem (i : ℕ) :
(g.trunc (g.map (Ideal.Quotient.mk I)).order.toNat).coeff i ∈ I := by
rw [coeff_trunc]
split_ifs with h
· simpa [← RingHom.mem_ker] using coeff_of_lt_order_toNat _ h
· exact zero_mem _ | 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 | coeff_trunc_order_mem | null |
isUnit_shift : IsUnit <| mk fun i ↦
coeff (i + (g.map (Ideal.Quotient.mk I)).order.toNat) g := by
simpa [isUnit_iff_constantCoeff] | 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_shift | null |
noncomputable seq (H : g.IsWeierstrassDivisorAt I) (f : A⟦X⟧) : ℕ → A⟦X⟧
| 0 => 0
| k + 1 =>
H.seq f k + (mk fun i ↦ coeff (i + (g.map (Ideal.Quotient.mk I)).order.toNat)
(f - g * H.seq f k)) * H.isUnit_shift.unit⁻¹
variable (a : A) (f f' : A⟦X⟧) | 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 | seq | The inductively constructed sequence `qₖ` in the proof of Weierstrass division. |
coeff_seq_mem (k : ℕ) {i : ℕ} (hi : i ≥ (g.map (Ideal.Quotient.mk I)).order.toNat) :
coeff i (f - g * H.seq f k) ∈ I ^ k := by
induction k generalizing hi i with
| zero => simp
| succ k hq =>
rw [seq]
set q := H.seq f k
set s := f - g * q
set n := (g.map (Ideal.Quotient.mk I)).order.toNat
have hs := s.eq_X_pow_mul_shift_add_trunc n
set s₀ := s.trunc n
set s₁ := PowerSeries.mk fun i ↦ coeff (i + n) s
set q' := q + s₁ * H.isUnit_shift.unit⁻¹
have key : f - g * q' = (s₀ : A⟦X⟧) - (g.trunc n : A⟦X⟧) * s₁ * H.isUnit_shift.unit⁻¹ := by
trans s + g * (q - q')
· simp_rw [s]; ring
simp_rw [q']
rw [sub_add_cancel_left, mul_neg, ← mul_assoc, mul_right_comm]
nth_rw 1 [g.eq_X_pow_mul_shift_add_trunc n]
rw [add_mul, mul_assoc, IsUnit.mul_val_inv, hs]
ring
rw [key, map_sub, Polynomial.coeff_coe, coeff_trunc, if_neg hi.not_gt, zero_sub, neg_mem_iff,
pow_succ']
refine coeff_mul_mem_ideal_of_coeff_left_mem_ideal' (fun i ↦ ?_) i
refine coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal'
(by simp [n, g.coeff_trunc_order_mem]) (fun i ↦ ?_) i
rw [coeff_mk]
exact hq (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 | coeff_seq_mem | null |
coeff_seq_succ_sub_seq_mem (k i : ℕ) :
coeff i (H.seq f (k + 1) - H.seq f k) ∈ I ^ k := by
rw [seq, add_sub_cancel_left]
refine coeff_mul_mem_ideal_of_coeff_left_mem_ideal' (fun i ↦ ?_) i
rw [coeff_mk]
exact H.coeff_seq_mem f k (by simp)
@[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 | coeff_seq_succ_sub_seq_mem | null |
seq_zero : H.seq f 0 = 0 := rfl | 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 | seq_zero | null |
seq_one : H.seq f 1 = (PowerSeries.mk fun i ↦ coeff
(i + (g.map (Ideal.Quotient.mk I)).order.toNat) f) * H.isUnit_shift.unit⁻¹ := by
simp_rw [seq, mul_zero, zero_add, sub_zero] | 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 | seq_one | null |
noncomputable divCoeff [IsPrecomplete I A] (i : ℕ) :=
Classical.indefiniteDescription _ <| IsPrecomplete.prec' (I := I)
(fun k ↦ coeff i (H.seq f k)) fun {m} {n} hn ↦ by
induction n, hn using Nat.le_induction with
| base => rw [SModEq.def]
| succ n hn ih =>
refine ih.trans (SModEq.symm ?_)
rw [SModEq.sub_mem, smul_eq_mul, Ideal.mul_top, ← map_sub]
exact Ideal.pow_le_pow_right hn (H.coeff_seq_succ_sub_seq_mem f n i) | 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 | divCoeff | The (bundled version of) coefficient of the limit `q` of the
inductively constructed sequence `qₖ` in the proof of Weierstrass division. |
noncomputable div [IsPrecomplete I A] : A⟦X⟧ := PowerSeries.mk fun i ↦ (H.divCoeff f i).1 | 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 | div | The limit `q` of the
inductively constructed sequence `qₖ` in the proof of Weierstrass division. |
coeff_div [IsPrecomplete I A] (i : ℕ) : coeff i (H.div f) = (H.divCoeff f i).1 := by
simp [div] | 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 | coeff_div | null |
coeff_div_sub_seq_mem [IsPrecomplete I A] (k i : ℕ) :
coeff i (H.div f - (H.seq f k)) ∈ I ^ k := by
simpa [coeff_div, SModEq.sub_mem] using ((H.divCoeff f i).2 k).symm | 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 | coeff_div_sub_seq_mem | null |
noncomputable mod [IsPrecomplete I A] : A[X] :=
(f - g * H.div f).trunc (g.map (Ideal.Quotient.mk I)).order.toNat | 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 | mod | The remainder `r` in the proof of Weierstrass division. |
isWeierstrassDivisionAt_div_mod [IsAdicComplete I A] :
f.IsWeierstrassDivisionAt g (H.div f) (H.mod f) I := by
rcases eq_or_ne I ⊤ with rfl | hI
· have := ‹IsAdicComplete ⊤ A›.toIsHausdorff.subsingleton
rw [Subsingleton.elim f 0, Subsingleton.elim (H.div 0) 0, Subsingleton.elim (H.mod 0) 0]
exact g.isWeierstrassDivisionAt_zero _
constructor
· exact degree_trunc_lt _ _
· rw [mod, add_comm, ← sub_eq_iff_eq_add]
ext i
rw [Polynomial.coeff_coe, coeff_trunc]
split_ifs with hi
· rfl
refine IsHausdorff.haus' (I := I) _ fun k ↦ ?_
rw [SModEq.zero, smul_eq_mul, Ideal.mul_top, show f - g * H.div f =
f - g * (H.seq f k) - g * (H.div f - (H.seq f k)) by ring, map_sub]
exact Ideal.sub_mem _ (H.coeff_seq_mem f k (not_lt.1 hi)) <|
coeff_mul_mem_ideal_of_coeff_right_mem_ideal' (H.coeff_div_sub_seq_mem f k) i | 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 | isWeierstrassDivisionAt_div_mod | If the ring is `I`-adic complete, then `g` can be used as a divisor in Weierstrass division. |
eq_zero_of_mul_eq [IsHausdorff I A]
{q : A⟦X⟧} {r : A[X]} (hdeg : r.degree < (g.map (Ideal.Quotient.mk I)).order.toNat)
(heq : g * q = r) : q = 0 ∧ r = 0 := by
suffices ∀ k i, coeff i q ∈ I ^ k by
have hq : q = 0 := by
ext i
refine IsHausdorff.haus' (I := I) _ fun k ↦ ?_
rw [SModEq.zero, smul_eq_mul, Ideal.mul_top]
exact this _ _
rw [hq, mul_zero, Eq.comm, Polynomial.coe_eq_zero_iff] at heq
exact ⟨hq, heq⟩
intro k
induction k with
| zero => simp
| succ k ih =>
rw [g.eq_X_pow_mul_shift_add_trunc (g.map (Ideal.Quotient.mk I)).order.toNat] at heq
have h1 : ∀ i, coeff i r ∈ I ^ (k + 1) := fun i ↦ by
rcases lt_or_ge i (g.map (Ideal.Quotient.mk I)).order.toNat with hi | hi
· rw [← heq, pow_succ']
refine coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal i (fun j hj ↦ ?_)
(fun j _ ↦ ih j) i le_rfl
rw [map_add, Polynomial.coeff_coe]
refine Ideal.add_mem _ ?_ (g.coeff_trunc_order_mem I j)
simp_rw [coeff_X_pow_mul', if_neg (lt_of_le_of_lt hj hi).not_ge, zero_mem]
simp_rw [Polynomial.coeff_coe,
Polynomial.coeff_eq_zero_of_degree_lt (lt_of_lt_of_le hdeg (by simpa)), zero_mem]
rw [add_mul, mul_comm (X ^ _), ← eq_sub_iff_add_eq] at heq
replace heq := congr(H.isUnit_shift.unit⁻¹ * $heq)
rw [← mul_assoc, ← mul_assoc, IsUnit.val_inv_mul, one_mul] at heq
intro i
rw [← coeff_X_pow_mul _ (g.map (Ideal.Quotient.mk I)).order.toNat i, heq]
refine coeff_mul_mem_ideal_of_coeff_right_mem_ideal' (fun i ↦ ?_) _
rw [map_sub]
refine Ideal.sub_mem _ (h1 _) ?_
rw [pow_succ']
refine coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal' (fun i ↦ ?_) ih _
simp_rw [Polynomial.coeff_coe, g.coeff_trunc_order_mem] | 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_zero_of_mul_eq | If `g * q = r` for some power series `q` and some polynomial `r` whose degree is `< n`,
then `q` and `r` are all zero. This implies the uniqueness of Weierstrass division. |
eq_of_mul_add_eq_mul_add [IsHausdorff I A] {q q' : A⟦X⟧} {r r' : A[X]}
(hr : r.degree < (g.map (Ideal.Quotient.mk I)).order.toNat)
(hr' : r'.degree < (g.map (Ideal.Quotient.mk I)).order.toNat)
(heq : g * q + r = g * q' + r') : q = q' ∧ r = r' := by
replace heq : g * (q - q') = ↑(r' - r) := by
rw [← eq_sub_iff_add_eq] at heq
rw [Polynomial.coe_sub, mul_sub, heq]
ring
have h := H.eq_zero_of_mul_eq (lt_of_le_of_lt (r'.degree_sub_le r) (max_lt hr' hr)) heq
simp_rw [sub_eq_zero] at h
exact ⟨h.1, h.2.symm⟩
@[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 | eq_of_mul_add_eq_mul_add | If `g * q + r = g * q' + r'` for some power series `q`, `q'` and some polynomials `r`, `r'`
whose degrees are `< n`, then `q = q'` and `r = r'` are all zero.
This implies the uniqueness of Weierstrass division. |
div_add [IsAdicComplete I A] : H.div (f + f') = H.div f + H.div f' := by
have H1 := (H.isWeierstrassDivisionAt_div_mod f).add (H.isWeierstrassDivisionAt_div_mod f')
have H2 := H.isWeierstrassDivisionAt_div_mod (f + f')
exact (H.eq_of_mul_add_eq_mul_add H2.degree_lt H1.degree_lt
(H2.eq_mul_add.symm.trans H1.eq_mul_add)).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 | div_add | null |
div_smul [IsAdicComplete I A] : H.div (a • f) = a • H.div f := by
have H1 := (H.isWeierstrassDivisionAt_div_mod f).smul a
have H2 := H.isWeierstrassDivisionAt_div_mod (a • f)
exact (H.eq_of_mul_add_eq_mul_add H2.degree_lt H1.degree_lt
(H2.eq_mul_add.symm.trans H1.eq_mul_add)).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 | div_smul | null |
div_zero [IsAdicComplete I A] : H.div 0 = 0 := by
simpa using H.div_smul 0 0
@[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 | div_zero | null |
mod_add [IsAdicComplete I A] : H.mod (f + f') = H.mod f + H.mod f' := by
have H1 := (H.isWeierstrassDivisionAt_div_mod f).add (H.isWeierstrassDivisionAt_div_mod f')
have H2 := H.isWeierstrassDivisionAt_div_mod (f + f')
exact (H.eq_of_mul_add_eq_mul_add H2.degree_lt H1.degree_lt
(H2.eq_mul_add.symm.trans H1.eq_mul_add)).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 | mod_add | null |
mod_smul [IsAdicComplete I A] : H.mod (a • f) = a • H.mod f := by
have H1 := (H.isWeierstrassDivisionAt_div_mod f).smul a
have H2 := H.isWeierstrassDivisionAt_div_mod (a • f)
exact (H.eq_of_mul_add_eq_mul_add H2.degree_lt H1.degree_lt
(H2.eq_mul_add.symm.trans H1.eq_mul_add)).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 | mod_smul | null |
mod_zero [IsAdicComplete I A] : H.mod 0 = 0 := by
simpa using H.mod_smul 0 0 | 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 | mod_zero | null |
noncomputable mod' [IsAdicComplete I A] : A⟦X⟧ ⧸ Ideal.span {g} →ₗ[A] A[X] where
toFun := Quotient.lift (fun f ↦ H.mod f) fun f f' hf ↦ by
simp_rw [HasEquiv.Equiv, Submodule.quotientRel_def, Ideal.mem_span_singleton'] at hf
obtain ⟨a, ha⟩ := hf
obtain ⟨hf1, hf2⟩ := H.isWeierstrassDivisionAt_div_mod f
obtain ⟨hf'1, hf'2⟩ := H.isWeierstrassDivisionAt_div_mod f'
rw [eq_sub_iff_add_eq, hf2, hf'2, ← add_assoc, mul_comm, ← mul_add] at ha
exact (H.eq_of_mul_add_eq_mul_add hf'1 hf1 ha).2.symm
map_add' f f' := by
obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective f
obtain ⟨f', rfl⟩ := Ideal.Quotient.mk_surjective f'
exact H.mod_add f f'
map_smul' a f := by
obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective f
exact H.mod_smul a f
@[simp] | 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 | mod' | The remainder map `PowerSeries.IsWeierstrassDivisorAt.mod` induces a linear map
`A⟦X⟧ / (g) →ₗ[A] A[X]`. |
mod'_mk_eq_mod [IsAdicComplete I A] {f : A⟦X⟧} :
H.mod' (Ideal.Quotient.mk _ f) = H.mod f := rfl | 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 | mod'_mk_eq_mod | null |
div_coe_eq_zero [IsAdicComplete I A] {r : A[X]}
(hr : r.degree < (g.map (Ideal.Quotient.mk I)).order.toNat) : H.div r = 0 := by
obtain ⟨h1, h2⟩ := H.isWeierstrassDivisionAt_div_mod r
exact (H.eq_of_mul_add_eq_mul_add (q := H.div r) (q' := 0) h1 hr (by simpa using h2.symm)).1 | 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 | div_coe_eq_zero | null |
mod_coe_eq_self [IsAdicComplete I A] {r : A[X]}
(hr : r.degree < (g.map (Ideal.Quotient.mk I)).order.toNat) : H.mod r = r := by
obtain ⟨h1, h2⟩ := H.isWeierstrassDivisionAt_div_mod r
exact (H.eq_of_mul_add_eq_mul_add (q := H.div r) (q' := 0) h1 hr (by simpa using h2.symm)).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 | mod_coe_eq_self | null |
mk_mod'_eq_self [IsAdicComplete I A] {f : A⟦X⟧ ⧸ Ideal.span {g}} :
Ideal.Quotient.mk _ (H.mod' f : A⟦X⟧) = f := by
obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective f
rw [mod'_mk_eq_mod, Eq.comm, Ideal.Quotient.mk_eq_mk_iff_sub_mem, Ideal.mem_span_singleton']
use H.div f
rw [eq_sub_iff_add_eq, mul_comm, (H.isWeierstrassDivisionAt_div_mod f).2.symm] | 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 | mk_mod'_eq_self | null |
@[simps! apply symm_apply]
noncomputable _root_.Polynomial.IsDistinguishedAt.algEquivQuotient :
(A[X] ⧸ Ideal.span {g}) ≃ₐ[A] A⟦X⟧ ⧸ Ideal.span {(g : A⟦X⟧)} where
__ := Ideal.quotientMapₐ _ (Polynomial.coeToPowerSeries.algHom A) fun a ha ↦ by
obtain ⟨b, hb⟩ := Ideal.mem_span_singleton'.1 ha
simp only [Ideal.mem_comap, Polynomial.coeToPowerSeries.algHom_apply, Algebra.algebraMap_self,
map_id, id_eq, Ideal.mem_span_singleton']
exact ⟨b, by simp [← hb]⟩
invFun := Ideal.Quotient.mk _ ∘ H.isWeierstrassDivisorAt'.mod'
left_inv f := by
rcases subsingleton_or_nontrivial A with _ | _
· have : Subsingleton A[X] := inferInstance
have : Subsingleton (A[X] ⧸ Ideal.span {g}) := Quot.Subsingleton
exact Subsingleton.elim _ _
have hI : I ≠ ⊤ := by
rintro rfl
exact not_subsingleton _ ‹IsAdicComplete ⊤ A›.toIsHausdorff.subsingleton
have := Ideal.Quotient.nontrivial hI
obtain ⟨f, hfdeg, rfl⟩ : ∃ r : A[X], r.degree < g.degree ∧ Ideal.Quotient.mk _ r = f := by
obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective f
refine ⟨f %ₘ g, Polynomial.degree_modByMonic_lt f H.monic, ?_⟩
rw [Eq.comm, Ideal.Quotient.mk_eq_mk_iff_sub_mem, Ideal.mem_span_singleton']
exact ⟨f /ₘ g, by rw [Polynomial.modByMonic_eq_sub_mul_div _ H.monic]; ring⟩
have h1 : g.degree = ((g : A⟦X⟧).map (Ideal.Quotient.mk I)).order.toNat := by
convert H.degree_eq_coe_lift_order_map g 1
(by rwa [constantCoeff_one, ← Ideal.ne_top_iff_one]) (by simp)
exact (ENat.lift_eq_toNat_of_lt_top _).symm
dsimp
rw [Ideal.Quotient.mk_eq_mk_iff_sub_mem, Ideal.mem_span_singleton']
exact ⟨0, by simp [H.isWeierstrassDivisorAt'.mod_coe_eq_self (hfdeg.trans_eq h1)]⟩
right_inv f := by exact H.isWeierstrassDivisorAt'.mk_mod'_eq_self | 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 | _root_.Polynomial.IsDistinguishedAt.algEquivQuotient | A distinguished polynomial `g` induces a natural isomorphism `A[X] / (g) ≃ₐ[A] A⟦X⟧ / (g)`. |
exists_isWeierstrassDivision [IsAdicComplete (IsLocalRing.maximalIdeal A) A]
(hg : g.map (IsLocalRing.residue A) ≠ 0) : ∃ q r, f.IsWeierstrassDivision g q r :=
⟨_, _, (IsWeierstrassDivisor.of_map_ne_zero hg).isWeierstrassDivisionAt_div_mod f⟩ | 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_isWeierstrassDivision | **Weierstrass division** ([washington_cyclotomic], Proposition 7.2): let `f`, `g` be
power series over a complete local ring, such that
the image of `g` in the residue field is not zero. Let `n` be the order of the image of `g` in the
residue field. Then there exists a power series `q` and a polynomial `r` of degree `< n`, such that
`f = g * q + r`. |
noncomputable weierstrassDiv [IsPrecomplete (IsLocalRing.maximalIdeal A) A] : A⟦X⟧ :=
open scoped Classical in
if hg : g.map (IsLocalRing.residue A) ≠ 0 then
(IsWeierstrassDivisor.of_map_ne_zero hg).div f
else
0 | 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 | weierstrassDiv | The quotient `q` in Weierstrass division, denoted by `f /ʷ g`. Note that when the image of
`g` in the residue field is zero, this is defined to be zero. |
noncomputable weierstrassMod [IsPrecomplete (IsLocalRing.maximalIdeal A) A] : A[X] :=
open scoped Classical in
if hg : g.map (IsLocalRing.residue A) ≠ 0 then
(IsWeierstrassDivisor.of_map_ne_zero hg).mod f
else
0
@[inherit_doc]
infixl:70 " /ʷ " => weierstrassDiv
@[inherit_doc]
infixl:70 " %ʷ " => weierstrassMod
@[simp] | 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 | weierstrassMod | The remainder `r` in Weierstrass division, denoted by `f %ʷ g`. Note that when the image of
`g` in the residue field is zero, this is defined to be zero. |
weierstrassDiv_zero_right [IsPrecomplete (IsLocalRing.maximalIdeal A) A] : f /ʷ 0 = 0 := by
rw [weierstrassDiv, dif_neg (by simp)]
alias weierstrassDiv_zero := weierstrassDiv_zero_right
@[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 | weierstrassDiv_zero_right | null |
weierstrassMod_zero_right [IsPrecomplete (IsLocalRing.maximalIdeal A) A] : f %ʷ 0 = 0 := by
rw [weierstrassMod, dif_neg (by simp)]
alias weierstrassMod_zero := weierstrassMod_zero_right | 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 | weierstrassMod_zero_right | null |
degree_weierstrassMod_lt [IsPrecomplete (IsLocalRing.maximalIdeal A) A] :
(f %ʷ g).degree < (g.map (IsLocalRing.residue A)).order.toNat := by
rw [weierstrassMod]
split_ifs with hg
· exact degree_trunc_lt _ _
· nontriviality A
rw [Polynomial.degree_zero]
exact WithBot.bot_lt_coe _ | 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_weierstrassMod_lt | null |
isWeierstrassDivision_weierstrassDiv_weierstrassMod
[IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
f.IsWeierstrassDivision g (f /ʷ g) (f %ʷ g) := by
simp_rw [weierstrassDiv, weierstrassMod, dif_pos hg]
exact (IsWeierstrassDivisor.of_map_ne_zero hg).isWeierstrassDivisionAt_div_mod f | 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_weierstrassDiv_weierstrassMod | null |
eq_mul_weierstrassDiv_add_weierstrassMod
[IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
f = g * (f /ʷ g) + (f %ʷ g) := by
simp_rw [weierstrassDiv, weierstrassMod, dif_pos hg]
exact ((IsWeierstrassDivisor.of_map_ne_zero hg).isWeierstrassDivisionAt_div_mod f).2
variable {f} 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 | eq_mul_weierstrassDiv_add_weierstrassMod | null |
IsWeierstrassDivision.elim [IsHausdorff (IsLocalRing.maximalIdeal A) A]
{q q' : A⟦X⟧} {r r' : A[X]}
(H : f.IsWeierstrassDivision g q r) (H2 : f.IsWeierstrassDivision g q' r') : q = q' ∧ r = r' :=
(IsWeierstrassDivisor.of_map_ne_zero hg).eq_of_mul_add_eq_mul_add H.1 H2.1 (H.2.symm.trans H2.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 | IsWeierstrassDivision.elim | The quotient `q` and the remainder `r` in the Weierstrass division are unique.
This result is stated using two `PowerSeries.IsWeierstrassDivision` assertions, and only requires
the ring being Hausdorff with respect to the maximal ideal. If you want `q` and `r` equal to
`f /ʷ g` and `f %ʷ g`, use `PowerSeries.IsWeierstrassDivision.unique`
instead, which requires the ring being complete with respect to the maximal ideal. |
IsWeierstrassDivision.eq_zero [IsHausdorff (IsLocalRing.maximalIdeal A) A]
{q : A⟦X⟧} {r : A[X]}
(H : IsWeierstrassDivision 0 g q r) : q = 0 ∧ r = 0 :=
H.elim hg (g.isWeierstrassDivisionAt_zero _)
variable {f} 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 | IsWeierstrassDivision.eq_zero | If `q` and `r` are quotient and remainder in the Weierstrass division `0 / g`, then they are
equal to `0`. |
IsWeierstrassDivision.unique [IsAdicComplete (IsLocalRing.maximalIdeal A) A]
{q : A⟦X⟧} {r : A[X]}
(H : f.IsWeierstrassDivision g q r) : q = f /ʷ g ∧ r = f %ʷ g :=
H.elim hg (f.isWeierstrassDivision_weierstrassDiv_weierstrassMod hg) | 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.unique | If `q` and `r` are quotient and remainder in the Weierstrass division `f / g`, then they are
equal to `f /ʷ g` and `f %ʷ g`. |
@[simp]
add_weierstrassDiv [IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
(f + f') /ʷ g = f /ʷ g + f' /ʷ g := by
simp_rw [weierstrassDiv]
split_ifs <;> simp
@[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 | add_weierstrassDiv | null |
smul_weierstrassDiv [IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
(a • f) /ʷ g = a • (f /ʷ g) := by
simp_rw [weierstrassDiv]
split_ifs <;> simp
@[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 | smul_weierstrassDiv | null |
weierstrassDiv_zero_left [IsAdicComplete (IsLocalRing.maximalIdeal A) A] : 0 /ʷ g = 0 := by
simp_rw [weierstrassDiv]
split_ifs <;> simp
alias zero_weierstrassDiv := weierstrassDiv_zero_left
@[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 | weierstrassDiv_zero_left | null |
add_weierstrassMod [IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
(f + f') %ʷ g = f %ʷ g + f' %ʷ g := by
simp_rw [weierstrassMod]
split_ifs <;> simp
@[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 | add_weierstrassMod | null |
smul_weierstrassMod [IsAdicComplete (IsLocalRing.maximalIdeal A) A] :
(a • f) %ʷ g = a • (f %ʷ g) := by
simp_rw [weierstrassMod]
split_ifs <;> simp
@[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 | smul_weierstrassMod | null |
weierstrassMod_zero_left [IsAdicComplete (IsLocalRing.maximalIdeal A) A] : 0 %ʷ g = 0 := by
simp_rw [weierstrassMod]
split_ifs <;> simp
alias zero_weierstrassMod := weierstrassMod_zero_left | 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 | weierstrassMod_zero_left | null |
@[mk_iff]
IsWeierstrassFactorizationAt (g : A⟦X⟧) (f : A[X]) (h : A⟦X⟧) (I : Ideal A) : Prop where
isDistinguishedAt : f.IsDistinguishedAt I
isUnit : IsUnit h
eq_mul : g = f * h | structure | 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 | IsWeierstrassFactorizationAt | If `f` is a polynomial over `A`, `g` and `h` are power series over `A`,
then `PowerSeries.IsWeierstrassFactorizationAt g f h I` is a `Prop` which asserts that `f` is
distinguished at `I`, `h` is a unit, such that `g = f * h`. |
IsWeierstrassFactorization (g : A⟦X⟧) (f : A[X]) (h : A⟦X⟧) [IsLocalRing A] : Prop :=
g.IsWeierstrassFactorizationAt f h (IsLocalRing.maximalIdeal A) | 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 | IsWeierstrassFactorization | Version of `PowerSeries.IsWeierstrassFactorizationAt` for local rings with respect to
its maximal ideal. |
map_ne_zero_of_ne_top (hI : I ≠ ⊤) : g.map (Ideal.Quotient.mk I) ≠ 0 := by
have := Ideal.Quotient.nontrivial hI
rw [congr(map (Ideal.Quotient.mk I) $(H.eq_mul)), map_mul, ← Polynomial.polynomial_map_coe, ne_eq,
(H.isUnit.map _).mul_left_eq_zero]
exact_mod_cast f.map_monic_ne_zero (f := Ideal.Quotient.mk I) H.isDistinguishedAt.monic | 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_of_ne_top | null |
degree_eq_coe_lift_order_map_of_ne_top (hI : I ≠ ⊤) :
f.degree = (g.map (Ideal.Quotient.mk I)).order.lift
(order_finite_iff_ne_zero.2 (H.map_ne_zero_of_ne_top hI)) := by
refine H.isDistinguishedAt.degree_eq_coe_lift_order_map g h ?_ H.eq_mul
contrapose! hI
exact Ideal.eq_top_of_isUnit_mem _ hI (isUnit_iff_constantCoeff.1 H.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 | degree_eq_coe_lift_order_map_of_ne_top | null |
natDegree_eq_toNat_order_map_of_ne_top (hI : I ≠ ⊤) :
f.natDegree = (g.map (Ideal.Quotient.mk I)).order.toNat := by
rw [Polynomial.natDegree, H.degree_eq_coe_lift_order_map_of_ne_top hI,
ENat.lift_eq_toNat_of_lt_top]
exact WithBot.unbotD_coe _ _ | 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_of_ne_top | null |
@[simps! apply]
noncomputable algEquivQuotient [IsAdicComplete I A] :
(A[X] ⧸ Ideal.span {f}) ≃ₐ[A] A⟦X⟧ ⧸ Ideal.span {g} :=
H.isDistinguishedAt.algEquivQuotient.trans <| Ideal.quotientEquivAlgOfEq A <|
by rw [H.eq_mul, Ideal.span_singleton_mul_right_unit H.isUnit]
@[simp] | 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 | algEquivQuotient | If `g = f * h` is a Weierstrass factorization, then there is a
natural isomorphism `A[X] / (f) ≃ₐ[A] A⟦X⟧ / (g)`. |
algEquivQuotient_symm_apply [IsAdicComplete I A] (x : A⟦X⟧ ⧸ Ideal.span {g}) :
H.algEquivQuotient.symm x = Ideal.Quotient.mk _
(H.isDistinguishedAt.isWeierstrassDivisorAt'.mod' <| Ideal.quotientEquivAlgOfEq A
(by rw [H.eq_mul, Ideal.span_singleton_mul_right_unit H.isUnit]) x) := by
simp [algEquivQuotient] | 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 | algEquivQuotient_symm_apply | null |
mul {g' : A⟦X⟧} {f' : A[X]} {h' : A⟦X⟧} (H' : g'.IsWeierstrassFactorizationAt f' h' I) :
(g * g').IsWeierstrassFactorizationAt (f * f') (h * h') I :=
⟨H.isDistinguishedAt.mul H'.isDistinguishedAt, H.isUnit.mul H'.isUnit, by
rw [H.eq_mul, H'.eq_mul, Polynomial.coe_mul]; ring⟩ | 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 | mul | null |
smul {a : A} (ha : IsUnit a) : (a • g).IsWeierstrassFactorizationAt f (a • h) I := by
refine ⟨H.isDistinguishedAt, ?_, ?_⟩
· rw [Algebra.smul_def]
exact (ha.map _).mul H.isUnit
· simp [H.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 | smul | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.