File: Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean

full_name: Polynomial.annIdeal
code: /-- `annIdeal R a` is the *annihilating ideal* of all `p : R[X]` such that `p(a) = 0`.

The informal notation `p(a)` stand for `Polynomial.aeval a p`.
Again informally, the annihilating ideal of `a` is
`{ p ∈ R[X] | p(a) = 0 }`. This is an ideal in `R[X]`.
The formal definition uses the kernel of the aeval map. -/
noncomputable def annIdeal (a : A) : Ideal R[X] 
goal: Ideal R[X]

full_name: Polynomial.mem_annIdeal_iff_aeval_eq_zero
code: /-- It is useful to refer to ideal membership sometimes
 and the annihilation condition other times. -/
theorem mem_annIdeal_iff_aeval_eq_zero {a : A} {p : R[X]} : p ∈ annIdeal R a ↔ aeval a p = 0 
goal: p ∈ Polynomial.annIdeal R a ↔ (Polynomial.aeval a) p = 0

full_name: Polynomial.annIdealGenerator
code: /-- `annIdealGenerator 𝕜 a` is the monic generator of `annIdeal 𝕜 a`
if one exists, otherwise `0`.

Since `𝕜[X]` is a principal ideal domain there is a polynomial `g` such that
 `span 𝕜 {g} = annIdeal a`. This picks some generator.
 We prefer the monic generator of the ideal. -/
noncomputable def annIdealGenerator (a : A) : 𝕜[X] 
goal: 𝕜[X]

full_name: Polynomial.annIdealGenerator_eq_zero_iff
code: @[simp]
theorem annIdealGenerator_eq_zero_iff {a : A} : annIdealGenerator 𝕜 a = 0 ↔ annIdeal 𝕜 a = ⊥ 
goal: Polynomial.annIdealGenerator 𝕜 a = 0 ↔ Polynomial.annIdeal 𝕜 a = ⊥

full_name: Polynomial.span_singleton_annIdealGenerator
code: /-- `annIdealGenerator 𝕜 a` is indeed a generator. -/
@[simp]
theorem span_singleton_annIdealGenerator (a : A) :
    Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a 
goal: Ideal.span {Polynomial.annIdealGenerator 𝕜 a} = Polynomial.annIdeal 𝕜 a

full_name: Polynomial.annIdealGenerator_mem
code: /-- The annihilating ideal generator is a member of the annihilating ideal. -/
theorem annIdealGenerator_mem (a : A) : annIdealGenerator 𝕜 a ∈ annIdeal 𝕜 a 
goal: Polynomial.annIdealGenerator 𝕜 a ∈ Polynomial.annIdeal 𝕜 a

full_name: Polynomial.mem_iff_eq_smul_annIdealGenerator
code: theorem mem_iff_eq_smul_annIdealGenerator {p : 𝕜[X]} (a : A) :
    p ∈ annIdeal 𝕜 a ↔ ∃ s : 𝕜[X], p = s • annIdealGenerator 𝕜 a 
goal: p ∈ Polynomial.annIdeal 𝕜 a ↔ ∃ s, p = s • Polynomial.annIdealGenerator 𝕜 a

full_name: Polynomial.monic_annIdealGenerator
code: /-- The generator we chose for the annihilating ideal is monic when the ideal is non-zero. -/
theorem monic_annIdealGenerator (a : A) (hg : annIdealGenerator 𝕜 a ≠ 0) :
    Monic (annIdealGenerator 𝕜 a) 
goal: (Polynomial.annIdealGenerator 𝕜 a).Monic

full_name: Polynomial.annIdealGenerator_aeval_eq_zero
code: theorem annIdealGenerator_aeval_eq_zero (a : A) : aeval a (annIdealGenerator 𝕜 a) = 0 
goal: (Polynomial.aeval a) (Polynomial.annIdealGenerator 𝕜 a) = 0

full_name: Polynomial.mem_iff_annIdealGenerator_dvd
code: theorem mem_iff_annIdealGenerator_dvd {p : 𝕜[X]} {a : A} :
    p ∈ annIdeal 𝕜 a ↔ annIdealGenerator 𝕜 a ∣ p 
goal: p ∈ Polynomial.annIdeal 𝕜 a ↔ Polynomial.annIdealGenerator 𝕜 a ∣ p

full_name: Polynomial.degree_annIdealGenerator_le_of_mem
code: /-- The generator of the annihilating ideal has minimal degree among
 the non-zero members of the annihilating ideal -/
theorem degree_annIdealGenerator_le_of_mem (a : A) (p : 𝕜[X]) (hp : p ∈ annIdeal 𝕜 a)
    (hpn0 : p ≠ 0) : degree (annIdealGenerator 𝕜 a) ≤ degree p 
goal: (Polynomial.annIdealGenerator 𝕜 a).degree ≤ p.degree

full_name: Polynomial.annIdealGenerator_eq_minpoly
code: /-- The generator of the annihilating ideal is the minimal polynomial. -/
theorem annIdealGenerator_eq_minpoly (a : A) : annIdealGenerator 𝕜 a = minpoly 𝕜 a 
goal: Polynomial.annIdealGenerator 𝕜 a = minpoly 𝕜 a

full_name: Polynomial.monic_generator_eq_minpoly
code: /-- If a monic generates the annihilating ideal, it must match our choice
 of the annihilating ideal generator. -/
theorem monic_generator_eq_minpoly (a : A) (p : 𝕜[X]) (p_monic : p.Monic)
    (p_gen : Ideal.span {p} = annIdeal 𝕜 a) : annIdealGenerator 𝕜 a = p 
goal: Polynomial.annIdealGenerator 𝕜 a = p

full_name: Polynomial.span_minpoly_eq_annihilator
code: theorem span_minpoly_eq_annihilator {M} [AddCommGroup M] [Module 𝕜 M] (f : Module.End 𝕜 M) :
    Ideal.span {minpoly 𝕜 f} = Module.annihilator 𝕜[X] (Module.AEval' f) 
goal: Ideal.span {minpoly 𝕜 f} = Module.annihilator 𝕜[X] (Module.AEval' f)