File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

full_name: AddMonoidAlgebra.sup_support_add_le
code: theorem sup_support_add_le : (f + g).support.sup degb ≤ f.support.sup degb ⊔ g.support.sup degb 
goal: (f + g).support.sup degb ≤ f.support.sup degb ⊔ g.support.sup degb

full_name: AddMonoidAlgebra.le_inf_support_add
code: theorem le_inf_support_add : f.support.inf degt ⊓ g.support.inf degt ≤ (f + g).support.inf degt 
goal: f.support.inf degt ⊓ g.support.inf degt ≤ (f + g).support.inf degt

full_name: AddMonoidAlgebra.sup_support_mul_le
code: theorem sup_support_mul_le {degb : A → B} (degbm : ∀ {a b}, degb (a + b) ≤ degb a + degb b)
    (f g : R[A]) :
    (f * g).support.sup degb ≤ f.support.sup degb + g.support.sup degb 
goal: (f * g).support.sup degb ≤ f.support.sup degb + g.support.sup degb

full_name: AddMonoidAlgebra.le_inf_support_mul
code: theorem le_inf_support_mul {degt : A → T} (degtm : ∀ {a b}, degt a + degt b ≤ degt (a + b))
    (f g : R[A]) :
    f.support.inf degt + g.support.inf degt ≤ (f * g).support.inf degt 
goal: f.support.inf degt + g.support.inf degt ≤ (f * g).support.inf degt

full_name: AddMonoidAlgebra.sup_support_list_prod_le
code: theorem sup_support_list_prod_le (degb0 : degb 0 ≤ 0)
    (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) :
    ∀ l : List R[A],
      l.prod.support.sup degb ≤ (l.map fun f : R[A] => f.support.sup degb).sum
  
goal: l.prod.support.sup degb ≤ (List.map (fun f => f.support.sup degb) l).sum

full_name: AddMonoidAlgebra.le_inf_support_list_prod
code: theorem le_inf_support_list_prod (degt0 : 0 ≤ degt 0)
    (degtm : ∀ a b, degt a + degt b ≤ degt (a + b)) (l : List R[A]) :
    (l.map fun f : R[A] => f.support.inf degt).sum ≤ l.prod.support.inf degt 
goal: (List.map (fun f => f.support.inf degt) l).sum ≤ l.prod.support.inf degt

full_name: AddMonoidAlgebra.sup_support_pow_le
code: theorem sup_support_pow_le (degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
    (n : ℕ) (f : R[A]) : (f ^ n).support.sup degb ≤ n • f.support.sup degb 
goal: (f ^ n).support.sup degb ≤ n • f.support.sup degb

full_name: AddMonoidAlgebra.le_inf_support_pow
code: theorem le_inf_support_pow (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
    (n : ℕ) (f : R[A]) : n • f.support.inf degt ≤ (f ^ n).support.inf degt 
goal: n • f.support.inf degt ≤ (f ^ n).support.inf degt

full_name: AddMonoidAlgebra.sup_support_multiset_prod_le
code: theorem sup_support_multiset_prod_le (degb0 : degb 0 ≤ 0)
    (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) (m : Multiset R[A]) :
    m.prod.support.sup degb ≤ (m.map fun f : R[A] => f.support.sup degb).sum 
goal: m.prod.support.sup degb ≤ (Multiset.map (fun f => f.support.sup degb) m).sum

full_name: AddMonoidAlgebra.le_inf_support_multiset_prod
code: theorem le_inf_support_multiset_prod (degt0 : 0 ≤ degt 0)
    (degtm : ∀ a b, degt a + degt b ≤ degt (a + b)) (m : Multiset R[A]) :
    (m.map fun f : R[A] => f.support.inf degt).sum ≤ m.prod.support.inf degt 
goal: (Multiset.map (fun f => f.support.inf degt) m).sum ≤ m.prod.support.inf degt

full_name: AddMonoidAlgebra.sup_support_finset_prod_le
code: theorem sup_support_finset_prod_le (degb0 : degb 0 ≤ 0)
    (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) (s : Finset ι) (f : ι → R[A]) :
    (∏ i ∈ s, f i).support.sup degb ≤ ∑ i ∈ s, (f i).support.sup degb 
goal: (∏ i ∈ s, f i).support.sup degb ≤ ∑ i ∈ s, (f i).support.sup degb

full_name: AddMonoidAlgebra.le_inf_support_finset_prod
code: theorem le_inf_support_finset_prod (degt0 : 0 ≤ degt 0)
    (degtm : ∀ a b, degt a + degt b ≤ degt (a + b)) (s : Finset ι) (f : ι → R[A]) :
    (∑ i ∈ s, (f i).support.inf degt) ≤ (∏ i ∈ s, f i).support.inf degt 
goal: ∑ i ∈ s, (f i).support.inf degt ≤ (∏ i ∈ s, f i).support.inf degt

full_name: AddMonoidAlgebra.supDegree
code: /-- Let `R` be a semiring, let `A` be an `AddZeroClass`, let `B` be an `OrderBot`,
and let `D : A → B` be a "degree" function.
For an element `f : R[A]`, the element `supDegree f : B` is the supremum of all the elements in the
support of `f`, or `⊥` if `f` is zero.
Often, the Type `B` is `WithBot A`,
If, further, `A` has a linear order, then this notion coincides with the usual one,
using the maximum of the exponents. -/
abbrev supDegree (f : R[A]) : B 
goal: B

full_name: AddMonoidAlgebra.supDegree_add_le
code: theorem supDegree_add_le {f g : R[A]} :
    (f + g).supDegree D ≤ (f.supDegree D) ⊔ (g.supDegree D) 
goal: AddMonoidAlgebra.supDegree D (f + g) ≤ AddMonoidAlgebra.supDegree D f ⊔ AddMonoidAlgebra.supDegree D g

full_name: AddMonoidAlgebra.supDegree_neg
code: @[simp]
theorem supDegree_neg {f : R'[A]} :
    (-f).supDegree D = f.supDegree D 
goal: AddMonoidAlgebra.supDegree D (-f) = AddMonoidAlgebra.supDegree D f

full_name: AddMonoidAlgebra.supDegree_sub_le
code: theorem supDegree_sub_le {f g : R'[A]} :
    (f - g).supDegree D ≤ f.supDegree D ⊔ g.supDegree D 
goal: AddMonoidAlgebra.supDegree D (f - g) ≤ AddMonoidAlgebra.supDegree D f ⊔ AddMonoidAlgebra.supDegree D g

full_name: AddMonoidAlgebra.supDegree_sum_le
code: theorem supDegree_sum_le {ι} {s : Finset ι} {f : ι → R[A]} :
    (∑ i ∈ s, f i).supDegree D ≤ s.sup (fun i => (f i).supDegree D) 
goal: AddMonoidAlgebra.supDegree D (∑ i ∈ s, f i) ≤ s.sup fun i => AddMonoidAlgebra.supDegree D (f i)

full_name: AddMonoidAlgebra.supDegree_single_ne_zero
code: theorem supDegree_single_ne_zero (a : A) {r : R} (hr : r ≠ 0) :
    (single a r).supDegree D = D a 
goal: AddMonoidAlgebra.supDegree D (AddMonoidAlgebra.single a r) = D a

full_name: AddMonoidAlgebra.supDegree_single
code: theorem supDegree_single (a : A) (r : R) :
    (single a r).supDegree D = if r = 0 then ⊥ else D a 
goal: AddMonoidAlgebra.supDegree D (AddMonoidAlgebra.single a r) = if r = 0 then ⊥ else D a

full_name: AddMonoidAlgebra.supDegree_zero
code: @[simp]
theorem supDegree_zero : (0 : R[A]).supDegree D = ⊥ 
goal: AddMonoidAlgebra.supDegree D 0 = ⊥

full_name: AddMonoidAlgebra.ne_zero_of_supDegree_ne_bot
code: theorem ne_zero_of_supDegree_ne_bot : p.supDegree D ≠ ⊥ → p ≠ 0 
goal: AddMonoidAlgebra.supDegree D p ≠ ⊥ → p ≠ 0

full_name: AddMonoidAlgebra.ne_zero_of_not_supDegree_le
code: theorem ne_zero_of_not_supDegree_le {b : B} (h : ¬ p.supDegree D ≤ b) : p ≠ 0 
goal: p ≠ 0

full_name: AddMonoidAlgebra.apply_eq_zero_of_not_le_supDegree
code: theorem apply_eq_zero_of_not_le_supDegree {a : A} (hlt : ¬ D a ≤ p.supDegree D) : p a = 0 
goal: p a = 0

full_name: AddMonoidAlgebra.supDegree_mul_le
code: theorem supDegree_mul_le [CovariantClass B B (· + ·) (· ≤ ·)]
    [CovariantClass B B (Function.swap (· + ·)) (· ≤ ·)] :
    (p * q).supDegree D ≤ p.supDegree D + q.supDegree D 
goal: AddMonoidAlgebra.supDegree D (p * q) ≤ AddMonoidAlgebra.supDegree D p + AddMonoidAlgebra.supDegree D q

full_name: AddMonoidAlgebra.supDegree_prod_le
code: theorem supDegree_prod_le {R A B : Type*} [CommSemiring R] [AddCommMonoid A] [AddCommMonoid B]
    [SemilatticeSup B] [OrderBot B]
    [CovariantClass B B (· + ·) (· ≤ ·)] [CovariantClass B B (Function.swap (· + ·)) (· ≤ ·)]
    {D : A → B} (hzero : D 0 = 0) (hadd : ∀ a1 a2, D (a1 + a2) = D a1 + D a2)
    {ι} {s : Finset ι} {f : ι → R[A]} :
    (∏ i ∈ s, f i).supDegree D ≤ ∑ i ∈ s, (f i).supDegree D 
goal: AddMonoidAlgebra.supDegree D (∏ i ∈ s, f i) ≤ ∑ i ∈ s, AddMonoidAlgebra.supDegree D (f i)

full_name: AddMonoidAlgebra.apply_add_of_supDegree_le
code: theorem apply_add_of_supDegree_le (hD : D.Injective) {ap aq : A}
    (hp : p.supDegree D ≤ D ap) (hq : q.supDegree D ≤ D aq) :
    (p * q) (ap + aq) = p ap * q aq 
goal: (p * q) (ap + aq) = p ap * q aq

full_name: AddMonoidAlgebra.supDegree_withBot_some_comp
code: theorem supDegree_withBot_some_comp {s : AddMonoidAlgebra R A} (hs : s.support.Nonempty) :
    supDegree (WithBot.some ∘ D) s = supDegree D s 
goal: AddMonoidAlgebra.supDegree (WithBot.some ∘ D) s = ↑(AddMonoidAlgebra.supDegree D s)

full_name: AddMonoidAlgebra.infDegree
code: /-- Let `R` be a semiring, let `A` be an `AddZeroClass`, let `T` be an `OrderTop`,
and let `D : A → T` be a "degree" function.
For an element `f : R[A]`, the element `infDegree f : T` is the infimum of all the elements in the
support of `f`, or `⊤` if `f` is zero.
Often, the Type `T` is `WithTop A`,
If, further, `A` has a linear order, then this notion coincides with the usual one,
using the minimum of the exponents. -/
abbrev infDegree (f : R[A]) : T 
goal: T

full_name: AddMonoidAlgebra.le_infDegree_add
code: theorem le_infDegree_add (f g : R[A]) :
    (f.infDegree D) ⊓ (g.infDegree D) ≤ (f + g).infDegree D 
goal: AddMonoidAlgebra.infDegree D f ⊓ AddMonoidAlgebra.infDegree D g ≤ AddMonoidAlgebra.infDegree D (f + g)

full_name: AddMonoidAlgebra.le_infDegree_mul
code: theorem le_infDegree_mul (f g : R[A]) :
    f.infDegree D + g.infDegree D ≤ (f * g).infDegree D 
goal: AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMonoidAlgebra.infDegree (⇑D) (f * g)

full_name: AddMonoidAlgebra.infDegree_withTop_some_comp
code: theorem infDegree_withTop_some_comp {s : AddMonoidAlgebra R A} (hs : s.support.Nonempty) :
    infDegree (WithTop.some ∘ D) s = infDegree D s 
goal: AddMonoidAlgebra.infDegree (WithTop.some ∘ D) s = ↑(AddMonoidAlgebra.infDegree D s)