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 ⌀ |
|---|---|---|---|---|---|---|
algebraMap_eval_T [Algebra R R'] (x : R) (n : ℤ) :
algebraMap R R' ((T R n).eval x) = (T R' n).eval (algebraMap R R' x) := by
rw [← aeval_algebraMap_apply_eq_algebraMap_eval, aeval_T]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | algebraMap_eval_T | null |
algebraMap_eval_U [Algebra R R'] (x : R) (n : ℤ) :
algebraMap R R' ((U R n).eval x) = (U R' n).eval (algebraMap R R' x) := by
rw [← aeval_algebraMap_apply_eq_algebraMap_eval, aeval_U]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | algebraMap_eval_U | null |
algebraMap_eval_C [Algebra R R'] (x : R) (n : ℤ) :
algebraMap R R' ((C R n).eval x) = (C R' n).eval (algebraMap R R' x) := by
rw [← aeval_algebraMap_apply_eq_algebraMap_eval, aeval_C]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | algebraMap_eval_C | null |
algebraMap_eval_S [Algebra R R'] (x : R) (n : ℤ) :
algebraMap R R' ((S R n).eval x) = (S R' n).eval (algebraMap R R' x) := by
rw [← aeval_algebraMap_apply_eq_algebraMap_eval, aeval_S] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | algebraMap_eval_S | null |
T_derivative_eq_U (n : ℤ) : derivative (T R n) = n * U R (n - 1) := by
induction n using Polynomial.Chebyshev.induct with
| zero => simp
| one =>
simp
| add_two n ih1 ih2 =>
have h₁ := congr_arg derivative (T_add_two R n)
have h₂ := U_sub_one R n
have h₃ := T_eq_U_sub_X_mul_U R (n + 1)
simp only [derivative_sub, derivative_mul, derivative_ofNat, derivative_X] at h₁
linear_combination (norm := (push_cast; ring_nf))
h₁ - ih2 + 2 * (X : R[X]) * ih1 + 2 * h₃ - n * h₂
| neg_add_one n ih1 ih2 =>
have h₁ := congr_arg derivative (T_sub_one R (-n))
have h₂ := U_sub_two R (-n)
have h₃ := T_eq_U_sub_X_mul_U R (-n)
simp only [derivative_sub, derivative_mul, derivative_ofNat, derivative_X] at h₁
linear_combination (norm := (push_cast; ring_nf))
-ih2 + 2 * (X : R[X]) * ih1 + h₁ + 2 * h₃ + (n + 1) * h₂ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | T_derivative_eq_U | null |
one_sub_X_sq_mul_derivative_T_eq_poly_in_T (n : ℤ) :
(1 - X ^ 2) * derivative (T R (n + 1)) = (n + 1 : R[X]) * (T R n - X * T R (n + 1)) := by
have H₁ := one_sub_X_sq_mul_U_eq_pol_in_T R n
have H₂ := T_derivative_eq_U (R := R) (n + 1)
have h₁ := T_add_two R n
linear_combination (norm := (push_cast; ring_nf))
(-n - 1) * h₁ + (-(X : R[X]) ^ 2 + 1) * H₂ + (n + 1) * H₁ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | one_sub_X_sq_mul_derivative_T_eq_poly_in_T | null |
add_one_mul_T_eq_poly_in_U (n : ℤ) :
((n : R[X]) + 1) * T R (n + 1) = X * U R n - (1 - X ^ 2) * derivative (U R n) := by
have h₁ := congr_arg derivative <| T_eq_X_mul_T_sub_pol_U R n
simp only [derivative_sub, derivative_mul, derivative_X, derivative_one, derivative_X_pow,
T_derivative_eq_U, C_eq_natCast] at h₁
have h₂ := T_eq_U_sub_X_mul_U R (n + 1)
linear_combination (norm := (push_cast; ring_nf))
h₁ + (n + 2) * h₂
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | add_one_mul_T_eq_poly_in_U | null |
T_mul_T (m k : ℤ) : 2 * T R m * T R k = T R (m + k) + T R (m - k) := by
induction k using Polynomial.Chebyshev.induct with
| zero => simp [two_mul]
| one => rw [T_add_one, T_one]; ring
| add_two k ih1 ih2 =>
have h₁ := T_add_two R (m + k)
have h₂ := T_sub_two R (m - k)
have h₃ := T_add_two R k
linear_combination (norm := ring_nf) 2 * T R m * h₃ - h₂ - h₁ - ih2 + 2 * (X : R[X]) * ih1
| neg_add_one k ih1 ih2 =>
have h₁ := T_add_two R (m + (-k - 1))
have h₂ := T_sub_two R (m - (-k - 1))
have h₃ := T_add_two R (-k - 1)
linear_combination (norm := ring_nf) 2 * T R m * h₃ - h₂ - h₁ - ih2 + 2 * (X : R[X]) * ih1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | T_mul_T | Twice the product of two Chebyshev `T` polynomials is the sum of two other Chebyshev `T`
polynomials. |
C_mul_C (m k : ℤ) : C R m * C R k = C R (m + k) + C R (m - k) := by
induction k using Polynomial.Chebyshev.induct with
| zero => simp [mul_two]
| one => rw [C_add_one, C_one]; ring
| add_two k ih1 ih2 =>
have h₁ := C_add_two R (m + k)
have h₂ := C_sub_two R (m - k)
have h₃ := C_add_two R k
linear_combination (norm := ring_nf) C R m * h₃ - h₂ - h₁ - ih2 + (X:R[X]) * ih1
| neg_add_one k ih1 ih2 =>
have h₁ := C_add_two R (m + (-k - 1))
have h₂ := C_sub_two R (m - (-k - 1))
have h₃ := C_add_two R (-k - 1)
linear_combination (norm := ring_nf) C R m * h₃ - h₂ - h₁ - ih2 + (X:R[X]) * ih1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | C_mul_C | The product of two Chebyshev `C` polynomials is the sum of two other Chebyshev `C` polynomials. |
T_mul (m n : ℤ) : T R (m * n) = (T R m).comp (T R n) := by
induction m using Polynomial.Chebyshev.induct with
| zero => simp
| one => simp
| add_two m ih1 ih2 =>
have h₁ := T_mul_T R ((m + 1) * n) n
have h₂ := congr_arg (comp · (T R n)) <| T_add_two R m
simp only [sub_comp, mul_comp, ofNat_comp, X_comp] at h₂
linear_combination (norm := ring_nf) -ih2 - h₂ - h₁ + 2 * T R n * ih1
| neg_add_one m ih1 ih2 =>
have h₁ := T_mul_T R ((-m) * n) n
have h₂ := congr_arg (comp · (T R n)) <| T_add_two R (-m - 1)
simp only [sub_comp, mul_comp, ofNat_comp, X_comp] at h₂
linear_combination (norm := ring_nf) -ih2 - h₂ - h₁ + 2 * T R n * ih1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | T_mul | The `(m * n)`-th Chebyshev `T` polynomial is the composition of the `m`-th and `n`-th. |
C_mul (m n : ℤ) : C R (m * n) = (C R m).comp (C R n) := by
induction m using Polynomial.Chebyshev.induct with
| zero => simp
| one => simp
| add_two m ih1 ih2 =>
have h₁ := C_mul_C R ((m + 1) * n) n
have h₂ := congr_arg (comp · (C R n)) <| C_add_two R m
simp only [sub_comp, mul_comp, X_comp] at h₂
linear_combination (norm := ring_nf) -ih2 - h₂ - h₁ + C R n * ih1
| neg_add_one m ih1 ih2 =>
have h₁ := C_mul_C R ((-m) * n) n
have h₂ := congr_arg (comp · (C R n)) <| C_add_two R (-m - 1)
simp only [sub_comp, mul_comp, X_comp] at h₂
linear_combination (norm := ring_nf) -ih2 - h₂ - h₁ + C R n * ih1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Derivative",
"Mathlib.Algebra.Ring.NegOnePow",
"Mathlib.Tactic.LinearCombination"
] | Mathlib/RingTheory/Polynomial/Chebyshev.lean | C_mul | The `(m * n)`-th Chebyshev `C` polynomial is the composition of the `m`-th and `n`-th. |
IsPrimitive (p : R[X]) : Prop :=
∀ r : R, C r ∣ p → IsUnit r | def | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive | A polynomial is primitive when the only constant polynomials dividing it are units.
Note: This has nothing to do with minimal polynomials of primitive elements in finite fields. |
isPrimitive_iff_isUnit_of_C_dvd {p : R[X]} : p.IsPrimitive ↔ ∀ r : R, C r ∣ p → IsUnit r :=
Iff.rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isPrimitive_iff_isUnit_of_C_dvd | null |
isPrimitive_one : IsPrimitive (1 : R[X]) := fun _ h =>
isUnit_C.mp (isUnit_of_dvd_one h) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isPrimitive_one | null |
Monic.isPrimitive {p : R[X]} (hp : p.Monic) : p.IsPrimitive := by
rintro r ⟨q, h⟩
exact isUnit_of_mul_eq_one r (q.coeff p.natDegree) (by rwa [← coeff_C_mul, ← h]) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | Monic.isPrimitive | null |
IsPrimitive.ne_zero [Nontrivial R] {p : R[X]} (hp : p.IsPrimitive) : p ≠ 0 := by
rintro rfl
exact (hp 0 (dvd_zero (C 0))).ne_zero rfl | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive.ne_zero | null |
isPrimitive_of_dvd {p q : R[X]} (hp : IsPrimitive p) (hq : q ∣ p) : IsPrimitive q :=
fun a ha => isPrimitive_iff_isUnit_of_C_dvd.mp hp a (dvd_trans ha hq) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isPrimitive_of_dvd | null |
_root_.Irreducible.isPrimitive [NoZeroDivisors R]
{p : Polynomial R} (hp : Irreducible p) (hp' : p.natDegree ≠ 0) : p.IsPrimitive := by
rintro r ⟨q, hq⟩
suffices ¬IsUnit q by simpa using ((hp.2 hq).resolve_right this).map Polynomial.constantCoeff
intro H
have hr : r ≠ 0 := by rintro rfl; simp_all
obtain ⟨s, hs, rfl⟩ := Polynomial.isUnit_iff.mp H
simp [hq, Polynomial.natDegree_C_mul hr] at hp' | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | _root_.Irreducible.isPrimitive | An irreducible nonconstant polynomial over a domain is primitive. |
content (p : R[X]) : R :=
p.support.gcd p.coeff | def | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content | `p.content` is the `gcd` of the coefficients of `p`. |
content_dvd_coeff {p : R[X]} (n : ℕ) : p.content ∣ p.coeff n := by
by_cases h : n ∈ p.support
· apply Finset.gcd_dvd h
rw [mem_support_iff, Classical.not_not] at h
rw [h]
apply dvd_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_dvd_coeff | null |
content_C {r : R} : (C r).content = normalize r := by
rw [content]
by_cases h0 : r = 0
· simp [h0]
have h : (C r).support = {0} := support_monomial _ h0
simp [h]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_C | null |
content_zero : content (0 : R[X]) = 0 := by rw [← C_0, content_C, normalize_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_zero | null |
content_one : content (1 : R[X]) = 1 := by rw [← C_1, content_C, normalize_one] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_one | null |
content_X_mul {p : R[X]} : content (X * p) = content p := by
rw [content, content, Finset.gcd_def, Finset.gcd_def]
refine congr rfl ?_
have h : (X * p).support = p.support.map ⟨Nat.succ, Nat.succ_injective⟩ := by
ext a
simp only [Finset.mem_map, Function.Embedding.coeFn_mk, Ne, mem_support_iff]
rcases a with - | a
· simp
rw [mul_comm, coeff_mul_X]
constructor
· intro h
use a
· rintro ⟨b, ⟨h1, h2⟩⟩
rw [← Nat.succ_injective h2]
apply h1
rw [h]
simp only [Finset.map_val, Function.comp_apply, Function.Embedding.coeFn_mk, Multiset.map_map]
refine congr (congr rfl ?_) rfl
ext a
rw [mul_comm]
simp [coeff_mul_X]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_X_mul | null |
content_X_pow {k : ℕ} : content ((X : R[X]) ^ k) = 1 := by
induction k with
| zero => simp
| succ k hi => rw [pow_succ', content_X_mul, hi]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_X_pow | null |
content_X : content (X : R[X]) = 1 := by rw [← mul_one X, content_X_mul, content_one] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_X | null |
content_C_mul (r : R) (p : R[X]) : (C r * p).content = normalize r * p.content := by
by_cases h0 : r = 0; · simp [h0]
rw [content]; rw [content]; rw [← Finset.gcd_mul_left]
refine congr (congr rfl ?_) ?_ <;> ext <;> simp [h0, mem_support_iff]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_C_mul | null |
content_monomial {r : R} {k : ℕ} : content (monomial k r) = normalize r := by
rw [← C_mul_X_pow_eq_monomial, content_C_mul, content_X_pow, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_monomial | null |
content_eq_zero_iff {p : R[X]} : content p = 0 ↔ p = 0 := by
rw [content, Finset.gcd_eq_zero_iff]
constructor <;> intro h
· ext n
by_cases h0 : n ∈ p.support
· rw [h n h0, coeff_zero]
· rw [mem_support_iff] at h0
push_neg at h0
simp [h0]
· intro x
simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_eq_zero_iff | null |
normalize_content {p : R[X]} : normalize p.content = p.content :=
Finset.normalize_gcd
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | normalize_content | null |
normUnit_content {p : R[X]} : normUnit (content p) = 1 := by
by_cases hp0 : p.content = 0
· simp [hp0]
· ext
apply mul_left_cancel₀ hp0
rw [← normalize_apply, normalize_content, Units.val_one, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | normUnit_content | null |
content_eq_gcd_range_of_lt (p : R[X]) (n : ℕ) (h : p.natDegree < n) :
p.content = (Finset.range n).gcd p.coeff := by
apply dvd_antisymm_of_normalize_eq normalize_content Finset.normalize_gcd
· rw [Finset.dvd_gcd_iff]
intro i _
apply content_dvd_coeff _
· apply Finset.gcd_mono
intro i
simp only [mem_support_iff, Ne, Finset.mem_range]
contrapose!
intro h1
apply coeff_eq_zero_of_natDegree_lt (lt_of_lt_of_le h h1) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_eq_gcd_range_of_lt | null |
content_eq_gcd_range_succ (p : R[X]) :
p.content = (Finset.range p.natDegree.succ).gcd p.coeff :=
content_eq_gcd_range_of_lt _ _ (Nat.lt_succ_self _) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_eq_gcd_range_succ | null |
content_eq_gcd_leadingCoeff_content_eraseLead (p : R[X]) :
p.content = GCDMonoid.gcd p.leadingCoeff (eraseLead p).content := by
by_cases h : p = 0
· simp [h]
rw [← leadingCoeff_eq_zero, leadingCoeff, ← Ne, ← mem_support_iff] at h
rw [content, ← Finset.insert_erase h, Finset.gcd_insert, leadingCoeff, content,
eraseLead_support]
refine congr rfl (Finset.gcd_congr rfl fun i hi => ?_)
rw [Finset.mem_erase] at hi
rw [eraseLead_coeff, if_neg hi.1] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_eq_gcd_leadingCoeff_content_eraseLead | null |
dvd_content_iff_C_dvd {p : R[X]} {r : R} : r ∣ p.content ↔ C r ∣ p := by
rw [C_dvd_iff_dvd_coeff]
constructor
· intro h i
apply h.trans (content_dvd_coeff _)
· intro h
rw [content, Finset.dvd_gcd_iff]
intro i _
apply h i | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | dvd_content_iff_C_dvd | null |
C_content_dvd (p : R[X]) : C p.content ∣ p :=
dvd_content_iff_C_dvd.1 dvd_rfl | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | C_content_dvd | null |
isPrimitive_iff_content_eq_one {p : R[X]} : p.IsPrimitive ↔ p.content = 1 := by
rw [← normalize_content, normalize_eq_one, IsPrimitive]
simp_rw [← dvd_content_iff_C_dvd]
exact ⟨fun h => h p.content (dvd_refl p.content), fun h r hdvd => isUnit_of_dvd_unit hdvd h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isPrimitive_iff_content_eq_one | null |
IsPrimitive.content_eq_one {p : R[X]} (hp : p.IsPrimitive) : p.content = 1 :=
isPrimitive_iff_content_eq_one.mp hp | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive.content_eq_one | null |
noncomputable primPart (p : R[X]) : R[X] :=
letI := Classical.decEq R
if p = 0 then 1 else Classical.choose (C_content_dvd p) | def | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | primPart | The primitive part of a polynomial `p` is the primitive polynomial gained by dividing `p` by
`p.content`. If `p = 0`, then `p.primPart = 1`. |
eq_C_content_mul_primPart (p : R[X]) : p = C p.content * p.primPart := by
by_cases h : p = 0; · simp [h]
rw [primPart, if_neg h, ← Classical.choose_spec (C_content_dvd p)]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | eq_C_content_mul_primPart | null |
primPart_zero : primPart (0 : R[X]) = 1 :=
if_pos rfl | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | primPart_zero | null |
isPrimitive_primPart (p : R[X]) : p.primPart.IsPrimitive := by
by_cases h : p = 0; · simp [h]
rw [← content_eq_zero_iff] at h
rw [isPrimitive_iff_content_eq_one]
apply mul_left_cancel₀ h
conv_rhs => rw [p.eq_C_content_mul_primPart, mul_one, content_C_mul, normalize_content] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isPrimitive_primPart | null |
content_primPart (p : R[X]) : p.primPart.content = 1 :=
p.isPrimitive_primPart.content_eq_one | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_primPart | null |
primPart_ne_zero (p : R[X]) : p.primPart ≠ 0 :=
p.isPrimitive_primPart.ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | primPart_ne_zero | null |
natDegree_primPart (p : R[X]) : p.primPart.natDegree = p.natDegree := by
by_cases h : C p.content = 0
· rw [C_eq_zero, content_eq_zero_iff] at h
simp [h]
conv_rhs =>
rw [p.eq_C_content_mul_primPart, natDegree_mul h p.primPart_ne_zero, natDegree_C, zero_add]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | natDegree_primPart | null |
IsPrimitive.primPart_eq {p : R[X]} (hp : p.IsPrimitive) : p.primPart = p := by
rw [← one_mul p.primPart, ← C_1, ← hp.content_eq_one, ← p.eq_C_content_mul_primPart] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive.primPart_eq | null |
isUnit_primPart_C (r : R) : IsUnit (C r).primPart := by
by_cases h0 : r = 0
· simp [h0]
unfold IsUnit
refine
⟨⟨C ↑(normUnit r)⁻¹, C ↑(normUnit r), by rw [← RingHom.map_mul, Units.inv_mul, C_1], by
rw [← RingHom.map_mul, Units.mul_inv, C_1]⟩,
?_⟩
rw [← normalize_eq_zero, ← C_eq_zero] at h0
apply mul_left_cancel₀ h0
conv_rhs => rw [← content_C, ← (C r).eq_C_content_mul_primPart]
simp only [normalize_apply, RingHom.map_mul]
rw [mul_assoc, ← RingHom.map_mul, Units.mul_inv, C_1, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | isUnit_primPart_C | null |
primPart_dvd (p : R[X]) : p.primPart ∣ p :=
Dvd.intro_left (C p.content) p.eq_C_content_mul_primPart.symm | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | primPart_dvd | null |
aeval_primPart_eq_zero {S : Type*} [Ring S] [IsDomain S] [Algebra R S]
[NoZeroSMulDivisors R S] {p : R[X]} {s : S} (hpzero : p ≠ 0) (hp : aeval s p = 0) :
aeval s p.primPart = 0 := by
rw [eq_C_content_mul_primPart p, map_mul, aeval_C] at hp
refine eq_zero_of_ne_zero_of_mul_left_eq_zero ?_ hp
rwa [(FaithfulSMul.algebraMap_injective R S).ne_iff' (map_zero _), Ne, content_eq_zero_iff] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | aeval_primPart_eq_zero | null |
eval₂_primPart_eq_zero {S : Type*} [CommSemiring S] [IsDomain S] {f : R →+* S}
(hinj : Function.Injective f) {p : R[X]} {s : S} (hpzero : p ≠ 0) (hp : eval₂ f s p = 0) :
eval₂ f s p.primPart = 0 := by
rw [eq_C_content_mul_primPart p, eval₂_mul, eval₂_C] at hp
refine eq_zero_of_ne_zero_of_mul_left_eq_zero ?_ hp
rwa [hinj.ne_iff' (map_zero _), Ne, content_eq_zero_iff] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | eval₂_primPart_eq_zero | null |
gcd_content_eq_of_dvd_sub {a : R} {p q : R[X]} (h : C a ∣ p - q) :
GCDMonoid.gcd a p.content = GCDMonoid.gcd a q.content := by
rw [content_eq_gcd_range_of_lt p (max p.natDegree q.natDegree).succ
(lt_of_le_of_lt (le_max_left _ _) (Nat.lt_succ_self _))]
rw [content_eq_gcd_range_of_lt q (max p.natDegree q.natDegree).succ
(lt_of_le_of_lt (le_max_right _ _) (Nat.lt_succ_self _))]
apply Finset.gcd_eq_of_dvd_sub
intro x _
obtain ⟨w, hw⟩ := h
use w.coeff x
rw [← coeff_sub, hw, coeff_C_mul] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | gcd_content_eq_of_dvd_sub | null |
content_mul_aux {p q : R[X]} :
GCDMonoid.gcd (p * q).eraseLead.content p.leadingCoeff =
GCDMonoid.gcd (p.eraseLead * q).content p.leadingCoeff := by
rw [gcd_comm (content _) _, gcd_comm (content _) _]
apply gcd_content_eq_of_dvd_sub
rw [← self_sub_C_mul_X_pow, ← self_sub_C_mul_X_pow, sub_mul, sub_sub, add_comm, sub_add,
sub_sub_cancel, leadingCoeff_mul, RingHom.map_mul, mul_assoc, mul_assoc]
apply dvd_sub (Dvd.intro _ rfl) (Dvd.intro _ rfl)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_mul_aux | null |
content_mul {p q : R[X]} : (p * q).content = p.content * q.content := by
classical
suffices h :
∀ (n : ℕ) (p q : R[X]), (p * q).degree < n → (p * q).content = p.content * q.content by
apply h
apply lt_of_le_of_lt degree_le_natDegree (WithBot.coe_lt_coe.2 (Nat.lt_succ_self _))
intro n p q hpq
induction n generalizing p q with
| zero =>
rw [Nat.cast_zero, Nat.WithBot.lt_zero_iff, degree_eq_bot, mul_eq_zero] at hpq
rcases hpq with (rfl | rfl) <;> simp
| succ n ih => ?_
by_cases p0 : p = 0
· simp [p0]
by_cases q0 : q = 0
· simp [q0]
rw [degree_eq_natDegree (mul_ne_zero p0 q0), Nat.cast_lt,
Nat.lt_succ_iff_lt_or_eq, ← Nat.cast_lt (α := WithBot ℕ),
← degree_eq_natDegree (mul_ne_zero p0 q0), natDegree_mul p0 q0] at hpq
rcases hpq with (hlt | heq)
· apply ih _ _ hlt
rw [← p.natDegree_primPart, ← q.natDegree_primPart, ← Nat.cast_inj (R := WithBot ℕ),
Nat.cast_add, ← degree_eq_natDegree p.primPart_ne_zero,
← degree_eq_natDegree q.primPart_ne_zero] at heq
rw [p.eq_C_content_mul_primPart, q.eq_C_content_mul_primPart]
suffices h : (q.primPart * p.primPart).content = 1 by
rw [mul_assoc, content_C_mul, content_C_mul, mul_comm p.primPart, mul_assoc, content_C_mul,
content_C_mul, h, mul_one, content_primPart, content_primPart, mul_one, mul_one]
rw [← normalize_content, normalize_eq_one, isUnit_iff_dvd_one,
content_eq_gcd_leadingCoeff_content_eraseLead, leadingCoeff_mul, gcd_comm]
apply (gcd_mul_dvd_mul_gcd _ _ _).trans
rw [content_mul_aux, ih, content_primPart, mul_one, gcd_comm, ←
content_eq_gcd_leadingCoeff_content_eraseLead, content_primPart, one_mul,
mul_comm q.primPart, content_mul_aux, ih, content_primPart, mul_one, gcd_comm, ←
content_eq_gcd_leadingCoeff_content_eraseLead, content_primPart]
· rw [← heq, degree_mul, WithBot.add_lt_add_iff_right]
· apply degree_erase_lt p.primPart_ne_zero
· rw [Ne, degree_eq_bot]
apply q.primPart_ne_zero
· rw [mul_comm, ← heq, degree_mul, WithBot.add_lt_add_iff_left]
· apply degree_erase_lt q.primPart_ne_zero
· rw [Ne, degree_eq_bot]
apply p.primPart_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | content_mul | null |
IsPrimitive.mul {p q : R[X]} (hp : p.IsPrimitive) (hq : q.IsPrimitive) :
(p * q).IsPrimitive := by
rw [isPrimitive_iff_content_eq_one, content_mul, hp.content_eq_one, hq.content_eq_one, mul_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive.mul | null |
primPart_mul {p q : R[X]} (h0 : p * q ≠ 0) :
(p * q).primPart = p.primPart * q.primPart := by
rw [Ne, ← content_eq_zero_iff, ← C_eq_zero] at h0
apply mul_left_cancel₀ h0
conv_lhs =>
rw [← (p * q).eq_C_content_mul_primPart, p.eq_C_content_mul_primPart,
q.eq_C_content_mul_primPart]
rw [content_mul, RingHom.map_mul]
ring | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | primPart_mul | null |
IsPrimitive.dvd_primPart_iff_dvd {p q : R[X]} (hp : p.IsPrimitive) (hq : q ≠ 0) :
p ∣ q.primPart ↔ p ∣ q := by
refine ⟨fun h => h.trans (Dvd.intro_left _ q.eq_C_content_mul_primPart.symm), fun h => ?_⟩
rcases h with ⟨r, rfl⟩
apply Dvd.intro _
rw [primPart_mul hq, hp.primPart_eq] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | IsPrimitive.dvd_primPart_iff_dvd | null |
exists_primitive_lcm_of_isPrimitive {p q : R[X]} (hp : p.IsPrimitive) (hq : q.IsPrimitive) :
∃ r : R[X], r.IsPrimitive ∧ ∀ s : R[X], p ∣ s ∧ q ∣ s ↔ r ∣ s := by
classical
have h : ∃ (n : ℕ) (r : R[X]), r.natDegree = n ∧ r.IsPrimitive ∧ p ∣ r ∧ q ∣ r :=
⟨(p * q).natDegree, p * q, rfl, hp.mul hq, dvd_mul_right _ _, dvd_mul_left _ _⟩
rcases Nat.find_spec h with ⟨r, rdeg, rprim, pr, qr⟩
refine ⟨r, rprim, fun s => ⟨?_, fun rs => ⟨pr.trans rs, qr.trans rs⟩⟩⟩
suffices hs : ∀ (n : ℕ) (s : R[X]), s.natDegree = n → p ∣ s ∧ q ∣ s → r ∣ s from
hs s.natDegree s rfl
clear s
by_contra! con
rcases Nat.find_spec con with ⟨s, sdeg, ⟨ps, qs⟩, rs⟩
have s0 : s ≠ 0 := by
contrapose! rs
simp [rs]
have hs :=
Nat.find_min' h
⟨_, s.natDegree_primPart, s.isPrimitive_primPart, (hp.dvd_primPart_iff_dvd s0).2 ps,
(hq.dvd_primPart_iff_dvd s0).2 qs⟩
rw [← rdeg] at hs
by_cases sC : s.natDegree ≤ 0
· rw [eq_C_of_natDegree_le_zero (le_trans hs sC), isPrimitive_iff_content_eq_one, content_C,
normalize_eq_one] at rprim
rw [eq_C_of_natDegree_le_zero (le_trans hs sC), ← dvd_content_iff_C_dvd] at rs
apply rs rprim.dvd
have hcancel := natDegree_cancelLeads_lt_of_natDegree_le_natDegree hs (lt_of_not_ge sC)
rw [sdeg] at hcancel
apply Nat.find_min con hcancel
refine
⟨_, rfl, ⟨dvd_cancelLeads_of_dvd_of_dvd pr ps, dvd_cancelLeads_of_dvd_of_dvd qr qs⟩,
fun rcs => rs ?_⟩
rw [← rprim.dvd_primPart_iff_dvd s0]
rw [cancelLeads, tsub_eq_zero_iff_le.mpr hs, pow_zero, mul_one] at rcs
have h :=
dvd_add rcs (Dvd.intro_left (C (leadingCoeff s) * X ^ (natDegree s - natDegree r)) rfl)
have hC0 := rprim.ne_zero
rw [Ne, ← leadingCoeff_eq_zero, ← C_eq_zero] at hC0
rw [sub_add_cancel, ← rprim.dvd_primPart_iff_dvd (mul_ne_zero hC0 s0)] at h
rcases isUnit_primPart_C r.leadingCoeff with ⟨u, hu⟩
apply h.trans (Associated.symm ⟨u, _⟩).dvd
rw [primPart_mul (mul_ne_zero hC0 s0), hu, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | exists_primitive_lcm_of_isPrimitive | null |
dvd_iff_content_dvd_content_and_primPart_dvd_primPart {p q : R[X]} (hq : q ≠ 0) :
p ∣ q ↔ p.content ∣ q.content ∧ p.primPart ∣ q.primPart := by
constructor
· rintro ⟨r, rfl⟩
rw [content_mul, p.isPrimitive_primPart.dvd_primPart_iff_dvd hq]
exact ⟨dvd_mul_right .., dvd_mul_of_dvd_left p.primPart_dvd _⟩
· rintro ⟨h₁, h₂⟩
rw [p.eq_C_content_mul_primPart, q.eq_C_content_mul_primPart]
gcongr | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | dvd_iff_content_dvd_content_and_primPart_dvd_primPart | null |
degree_gcd_le_left {p : R[X]} (hp : p ≠ 0) (q) : (gcd p q).degree ≤ p.degree := by
have := natDegree_le_iff_degree_le.mp (natDegree_le_of_dvd (gcd_dvd_left p q) hp)
rwa [degree_eq_natDegree hp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | degree_gcd_le_left | null |
degree_gcd_le_right (p) {q : R[X]} (hq : q ≠ 0) : (gcd p q).degree ≤ q.degree := by
rw [gcd_comm]
exact degree_gcd_le_left hq p | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.Polynomial.CancelLeads",
"Mathlib.Algebra.Polynomial.EraseLead",
"Mathlib.Algebra.Polynomial.FieldDivision"
] | Mathlib/RingTheory/Polynomial/Content.lean | degree_gcd_le_right | null |
contentIdeal := span p.coeffs.toSet | def | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal | The content ideal of a polynomial `p` is the ideal generated by its coefficients. |
contentIdeal_def : p.contentIdeal = span p.coeffs.toSet := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_def | null |
contentIdeal_zero : (0 : R[X]).contentIdeal = ⊥ := by
simp [contentIdeal_def]
@[deprecated (since := "2025-07-01")]
alias contenIdeal_zero := contentIdeal_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_zero | null |
contentIdeal_eq_bot_iff : p.contentIdeal = ⊥ ↔ p = 0 := by
simp only [contentIdeal_def, span_eq_bot]
refine ⟨?_, fun h ↦ by simp [h]⟩
contrapose!
exact fun h ↦ ⟨p.leadingCoeff, coeff_mem_coeffs (leadingCoeff_ne_zero.mpr h),
leadingCoeff_ne_zero.mpr h⟩ | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_eq_bot_iff | null |
coeff_mem_contentIdeal (n : ℕ) : p.coeff n ∈ p.contentIdeal := by
by_cases h : p.coeff n = 0
· simp [h]
· apply subset_span
simpa using coeff_mem_coeffs h
@[simp] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | coeff_mem_contentIdeal | null |
contentIdeal_monomial (n : ℕ) (r : R) : (monomial n r).contentIdeal = span {r} := by
by_cases h : r = 0 <;>
simp [h, Set.singleton_zero, contentIdeal_def, coeffs_monomial]
@[simp] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_monomial | null |
contentIdeal_C (r : R) : (C r).contentIdeal = span {r} := by
rw [← monomial_zero_left]
exact contentIdeal_monomial 0 r
@[simp] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_C | null |
contentIdeal_one : (1 : R[X]).contentIdeal = ⊤ := by
rw [← span_singleton_one, ← contentIdeal_C 1, C_1] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_one | null |
contentIdeal_FG : p.contentIdeal.FG := ⟨p.coeffs, rfl⟩ | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_FG | null |
contentIdeal_map_eq_map_contentIdeal (f : R →+* S) :
(p.map f).contentIdeal = p.contentIdeal.map f := by
suffices span ((map f p).coeffs ∪ {0}) = span (f '' p.coeffs ∪ {0}) by
simpa [contentIdeal_def, map_span]
congr 1
ext s
by_cases hs : s = 0
· simp [hs]
· aesop (add simp mem_coeffs_iff) | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_map_eq_map_contentIdeal | null |
contentIdeal_mul_le_mul_contentIdeal (q : R[X]) :
(p * q).contentIdeal ≤ p.contentIdeal * q.contentIdeal := by
rw [contentIdeal_def, span_le]
simp only [Set.subset_def, Finset.mem_coe, mem_coeffs_iff]
rintro r ⟨n, _, rfl⟩
simp [coeff_mul, _root_.sum_mem, Submodule.mul_mem_mul, coeff_mem_contentIdeal] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_mul_le_mul_contentIdeal | null |
contentIdeal_le_contentIdeal_of_dvd (hpq : p ∣ q) : q.contentIdeal ≤ p.contentIdeal := by
obtain ⟨p', rfl⟩ := hpq
exact le_trans (p.contentIdeal_mul_le_mul_contentIdeal p') mul_le_right | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_le_contentIdeal_of_dvd | null |
_root_.Submodule.IsPrincipal.contentIdeal_generator_dvd_coeff
(h_prin : p.contentIdeal.IsPrincipal) (n : ℕ) : h_prin.generator ∣ p.coeff n := by
have := p.coeff_mem_contentIdeal n
rw [Submodule.IsPrincipal.mem_iff_eq_smul_generator] at this
obtain ⟨_, ha⟩ := this
simp [ha] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | _root_.Submodule.IsPrincipal.contentIdeal_generator_dvd_coeff | null |
_root_.Submodule.IsPrincipal.contentIdeal_generator_dvd
(h_prin : p.contentIdeal.IsPrincipal) : C h_prin.generator ∣ p := by
rw [C_dvd_iff_dvd_coeff]
exact fun i ↦ h_prin.contentIdeal_generator_dvd_coeff i | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | _root_.Submodule.IsPrincipal.contentIdeal_generator_dvd | null |
_root_.Submodule.IsPrincipal.contentIdeal_le_span_iff_dvd
(h_prin : p.contentIdeal.IsPrincipal) (r : R) :
p.contentIdeal ≤ span {r} ↔ C r ∣ p := by
constructor
· rw [← p.contentIdeal.span_singleton_generator]
intro _
calc
C r ∣ C h_prin.generator := by
apply _root_.map_dvd C
rwa [← span_singleton_le_span_singleton]
_ ∣ p := h_prin.contentIdeal_generator_dvd
· rw [← contentIdeal_C r]
exact fun h ↦ contentIdeal_le_contentIdeal_of_dvd h | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | _root_.Submodule.IsPrincipal.contentIdeal_le_span_iff_dvd | null |
isPrimitive_of_contentIdeal_eq_top (h : p.contentIdeal = ⊤) : p.IsPrimitive := by
have h_prin : p.contentIdeal.IsPrincipal := by
rw [h]
exact top_isPrincipal
intro r
simp [← h_prin.contentIdeal_le_span_iff_dvd r, h] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | isPrimitive_of_contentIdeal_eq_top | If the coefficients of `p` generate the whole ring, then `p` is primitive. |
_root_.Submodule.IsPrincipal.isPrimitive_iff_contentIdeal_eq_top
(h_prin : p.contentIdeal.IsPrincipal) : p.IsPrimitive ↔ p.contentIdeal = ⊤ := by
refine ⟨?_, fun h ↦ isPrimitive_of_contentIdeal_eq_top h⟩
contrapose!
simp only [IsPrimitive, not_forall]
intro _
use h_prin.generator, h_prin.contentIdeal_generator_dvd
simp_all [← Ideal.span_singleton_eq_top] | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | _root_.Submodule.IsPrincipal.isPrimitive_iff_contentIdeal_eq_top | null |
contentIdeal_eq_top_of_contentIdeal_mul_eq_top
(h : (p * q).contentIdeal = ⊤) : p.contentIdeal = ⊤ := by
apply le_antisymm le_top
calc
⊤ = (p * q).contentIdeal := h.symm
_ ≤ p.contentIdeal * q.contentIdeal := contentIdeal_mul_le_mul_contentIdeal p q
_ ≤ p.contentIdeal := mul_le_right | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_eq_top_of_contentIdeal_mul_eq_top | null |
mul_contentIdeal_le_radical_contentIdeal_mul :
p.contentIdeal * q.contentIdeal ≤ ((p * q).contentIdeal).radical := by
rw [radical_eq_sInf, le_sInf_iff]
intro P ⟨hpq, hPprime⟩
rw [hPprime.mul_le]
rw [← Ideal.mk_ker (I := P)] at hpq ⊢
simpa only [← map_eq_bot_iff_le_ker, ← contentIdeal_map_eq_map_contentIdeal, Polynomial.map_mul,
contentIdeal_eq_bot_iff, mul_eq_zero] using hpq | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | mul_contentIdeal_le_radical_contentIdeal_mul | null |
contentIdeal_mul_eq_top_of_contentIdeal_eq_top (hp : p.contentIdeal = ⊤)
(hq : q.contentIdeal = ⊤) : (p * q).contentIdeal = ⊤ := by
rw [← Ideal.radical_eq_top]
apply le_antisymm le_top
calc
⊤ = p.contentIdeal * q.contentIdeal := by simp [hp, hq]
_ ≤ ((p * q).contentIdeal).radical := mul_contentIdeal_le_radical_contentIdeal_mul | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_mul_eq_top_of_contentIdeal_eq_top | null |
contentIdeal_le_span_content : p.contentIdeal ≤ span {p.content} := by
rw [contentIdeal_def, span_le]
intro _ h1
rw [Finset.mem_coe, mem_coeffs_iff] at h1
obtain ⟨n, _, h2⟩ := h1
rw [SetLike.mem_coe, h2, mem_span_singleton]
exact content_dvd_coeff n | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | contentIdeal_le_span_content | null |
_root_.Submodule.IsPrincipal.contentIdeal_eq_span_content_of_isPrincipal
(h_prin : p.contentIdeal.IsPrincipal) : p.contentIdeal = span {p.content} := by
apply le_antisymm contentIdeal_le_span_content
rw [← p.contentIdeal.span_singleton_generator, span_singleton_le_span_singleton, content,
Finset.dvd_gcd_iff]
exact fun n _ ↦ h_prin.contentIdeal_generator_dvd_coeff n | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | _root_.Submodule.IsPrincipal.contentIdeal_eq_span_content_of_isPrincipal | null |
isPrimitive_iff_contentIdeal_eq_top : p.IsPrimitive ↔ p.contentIdeal = ⊤ :=
(IsBezout.isPrincipal_of_FG _ p.contentIdeal_FG).isPrimitive_iff_contentIdeal_eq_top | theorem | RingTheory | [
"Mathlib.Order.CompletePartialOrder",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Content"
] | Mathlib/RingTheory/Polynomial/ContentIdeal.lean | isPrimitive_iff_contentIdeal_eq_top | The polynomial `p` is primitive if and only if the coefficients of `p` generate the whole ring. |
noncomputable basis (n : ℕ) : Basis (Fin n) R R[X]_n :=
.ofEquivFun (degreeLTEquiv R n) | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | basis | Basis for `R[X]_n` given by `X^i` with `i < n`. |
@[simp] basis_repr : (basis R n).repr P i = (P : R[X]).coeff i :=
rfl
@[simp] lemma basis_val : (basis R n i : R[X]) = X ^ (i : ℕ) := by
change _ = ((⟨X ^ (i : ℕ), mem_degreeLT.2 <| (degree_X_pow_le i).trans_lt <|
Nat.cast_lt.2 i.is_lt⟩ : R[X]_n) : R[X])
refine congr_arg _ (Basis.apply_eq_iff.2 <| Finsupp.ext fun j ↦ ?_)
simp only [basis_repr, coeff_X_pow, eq_comm, Finsupp.single_apply, Fin.ext_iff]
variable (R m n) in | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | basis_repr | null |
noncomputable basisProd : Basis (Fin (m + n)) R (R[X]_m × R[X]_n) :=
((basis R m).prod (basis R n)).reindex finSumFinEquiv
@[simp] lemma basisProd_castAdd (m n : ℕ) (i : Fin m) :
basisProd R m n (i.castAdd n) = (basis R m i, 0) := by
rw [basisProd, Basis.reindex_apply, finSumFinEquiv_symm_apply_castAdd, Basis.prod_apply,
Sum.elim_inl, LinearMap.coe_inl, Function.comp_apply]
@[simp] lemma basisProd_natAdd (m n : ℕ) (i : Fin n) :
basisProd R m n (i.natAdd m) = (0, basis R n i) := by
rw [basisProd, Basis.reindex_apply, finSumFinEquiv_symm_apply_natAdd, Basis.prod_apply,
Sum.elim_inr, LinearMap.coe_inr, Function.comp_apply]
variable (R m n) in | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | basisProd | Basis for `R[X]_m × R[X]_n`. |
noncomputable addLinearEquiv :
R[X]_(m + n) ≃ₗ[R] R[X]_m × R[X]_n :=
Basis.equiv (basis ..) (basisProd ..) (Equiv.refl _) | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv | An isomorphism between `R[X]_(m + n)` and `R[X]_m × R[X]_n` given by the fact that the bases are
both indexed by `Fin (m + n)`. |
addLinearEquiv_castAdd (i : Fin m) :
addLinearEquiv R m n (basis R (m + n) (i.castAdd n)) = (basis R m i, 0) := by
rw [addLinearEquiv, Basis.equiv_apply, Equiv.refl_apply, basisProd_castAdd] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_castAdd | null |
addLinearEquiv_natAdd (i : Fin n) :
addLinearEquiv R m n (basis R (m + n) (i.natAdd m)) = (0, basis R n i) := by
rw [addLinearEquiv, Basis.equiv_apply, Equiv.refl_apply, basisProd_natAdd] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_natAdd | null |
addLinearEquiv_symm_apply_inl_basis (i : Fin m) :
(addLinearEquiv R m n).symm (LinearMap.inl R _ _ (basis R m i)) =
basis R (m + n) (i.castAdd n) :=
(LinearEquiv.symm_apply_eq _).2 (addLinearEquiv_castAdd i).symm | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply_inl_basis | null |
addLinearEquiv_symm_apply_inr_basis (j : Fin n) :
(addLinearEquiv R m n).symm (LinearMap.inr R _ _ (basis R n j)) =
basis R (m + n) (j.natAdd m) :=
(LinearEquiv.symm_apply_eq _).2 (addLinearEquiv_natAdd j).symm | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply_inr_basis | null |
addLinearEquiv_symm_apply_inl (P : R[X]_m) :
((addLinearEquiv R m n).symm (LinearMap.inl R _ _ P) : R[X]) = (P : R[X]) := by
rw [← (basis ..).sum_repr P]
simp [-LinearMap.coe_inl, addLinearEquiv_symm_apply_inl_basis] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply_inl | null |
addLinearEquiv_symm_apply_inr (Q : R[X]_n) :
((addLinearEquiv R m n).symm (LinearMap.inr R _ _ Q) : R[X]) = (Q : R[X]) * X ^ (m : ℕ) := by
rw [← (basis ..).sum_repr Q]
simp [-LinearMap.coe_inr, Finset.sum_mul, addLinearEquiv_symm_apply_inr_basis,
smul_eq_C_mul, mul_assoc, ← pow_add, add_comm] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply_inr | null |
addLinearEquiv_symm_apply (PQ) :
((addLinearEquiv R m n).symm PQ : R[X]) = (PQ.1 : R[X]) + (PQ.2 : R[X]) * X ^ (m : ℕ) := calc
_ = ((addLinearEquiv R m n).symm (LinearMap.inl R _ _ PQ.1 + LinearMap.inr R _ _ PQ.2) : R[X]) :=
by rw [LinearMap.inl_apply, LinearMap.inr_apply, Prod.add_def, add_zero, zero_add]
_ = _ := by rw [map_add, Submodule.coe_add,
addLinearEquiv_symm_apply_inl, addLinearEquiv_symm_apply_inr] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply | null |
addLinearEquiv_symm_apply' (PQ) :
((addLinearEquiv R m n).symm PQ : R[X]) = (PQ.1 : R[X]) + X ^ (m : ℕ) * (PQ.2 : R[X]) := by
rw [X_pow_mul, addLinearEquiv_symm_apply] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_symm_apply' | null |
addLinearEquiv_apply' {R : Type*} [Ring R] (f) :
((addLinearEquiv R m n f).1 : R[X]) = f %ₘ (X ^ m) ∧
((addLinearEquiv R m n f).2 : R[X]) = f /ₘ (X ^ m) := by
rw [and_comm, eq_comm, eq_comm (b := _ %ₘ _)]
nontriviality R; refine div_modByMonic_unique _ _ (monic_X_pow _) ⟨?_, ?_⟩
· rw [← addLinearEquiv_symm_apply', LinearEquiv.symm_apply_apply]
· rw [degree_X_pow, ← mem_degreeLT]; exact Subtype.prop _ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_apply' | null |
addLinearEquiv_apply_fst {R : Type*} [Ring R] (f) :
((addLinearEquiv R m n f).1 : R[X]) = f %ₘ (X ^ m) :=
(addLinearEquiv_apply' f).1 | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_apply_fst | null |
addLinearEquiv_apply_snd {R : Type*} [Ring R] (f) :
((addLinearEquiv R m n f).2 : R[X]) = f /ₘ (X ^ m) :=
(addLinearEquiv_apply' f).2 | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_apply_snd | null |
addLinearEquiv_apply {R : Type*} [Ring R] (f) :
addLinearEquiv R m n f =
(⟨f %ₘ (X ^ m), addLinearEquiv_apply_fst f ▸ Subtype.prop _⟩,
⟨f /ₘ (X ^ m), addLinearEquiv_apply_snd f ▸ Subtype.prop _⟩) :=
Prod.ext (Subtype.ext <| addLinearEquiv_apply_fst f) (Subtype.ext <| addLinearEquiv_apply_snd f) | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | addLinearEquiv_apply | null |
@[simp]
taylor_mem_degreeLT : taylor r f ∈ R[X]_n ↔ f ∈ R[X]_n := by simp [mem_degreeLT] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.LinearAlgebra.Matrix.Block",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/RingTheory/Polynomial/DegreeLT.lean | taylor_mem_degreeLT | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.