ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CanonicallyOrderedCommSemiring.list_prod_pos
@[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
    {α : Type*} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
    ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
  
Arguments: {α : Type u_2} [CanonicallyOrderedCommSemiring α] [Nontrivial α] {l : List α}
Goal: 0 < l.prod ↔ ∀ x ∈ l, 0 < x
-- List.Forall₂.prod_le_prod'
@[to_additive sum_le_sum]
lemma Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
    l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : List.Forall₂ (fun x x_1 => x ≤ x_1) l₁ l₂)
Goal: l₁.prod ≤ l₂.prod
-- List.Forall₂.sum_le_sum
@[to_additive sum_le_sum]
lemma Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
    l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : List.Forall₂ (fun x x_1 => x ≤ x_1) l₁ l₂)
Goal: l₁.sum ≤ l₂.sum
-- List.Sublist.sum_le_sum
@[to_additive sum_le_sum "If `l₁` is a sublist of `l₂` and all elements of `l₂` are nonnegative,
  then `l₁.sum ≤ l₂.sum`.
  One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 0 ≤ a` instead of `∀ a ∈ l₂, 0 ≤ a`
  but this lemma is not yet in `mathlib`."]
lemma Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : l₁.Sublist l₂) (h₁ : ∀ a ∈ l₂, 0 ≤ a)
Goal: l₁.sum ≤ l₂.sum
-- List.Sublist.prod_le_prod'
@[to_additive sum_le_sum "If `l₁` is a sublist of `l₂` and all elements of `l₂` are nonnegative,
  then `l₁.sum ≤ l₂.sum`.
  One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 0 ≤ a` instead of `∀ a ∈ l₂, 0 ≤ a`
  but this lemma is not yet in `mathlib`."]
lemma Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : l₁.Sublist l₂) (h₁ : ∀ a ∈ l₂, 1 ≤ a)
Goal: l₁.prod ≤ l₂.prod
-- List.SublistForall₂.sum_le_sum
@[to_additive sum_le_sum]
lemma SublistForall₂.prod_le_prod' [Preorder M]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass M M (· * ·) (· ≤ ·)]
    {l₁ l₂ : List M} (h : SublistForall₂ (· ≤ ·) l₁ l₂) (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) :
    l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : List.SublistForall₂ (fun x x_1 => x ≤ x_1) l₁ l₂) (h₁ : ∀ a ∈ l₂, 0 ≤ a)
Goal: l₁.sum ≤ l₂.sum
-- List.SublistForall₂.prod_le_prod'
@[to_additive sum_le_sum]
lemma SublistForall₂.prod_le_prod' [Preorder M]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass M M (· * ·) (· ≤ ·)]
    {l₁ l₂ : List M} (h : SublistForall₂ (· ≤ ·) l₁ l₂) (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) :
    l₁.prod ≤ l₂.prod 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l₁ l₂ : List M} (h : List.SublistForall₂ (fun x x_1 => x ≤ x_1) l₁ l₂) (h₁ : ∀ a ∈ l₂, 1 ≤ a)
Goal: l₁.prod ≤ l₂.prod
-- List.sum_le_sum
@[to_additive sum_le_sum]
lemma prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i) :
    (l.map f).prod ≤ (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i)
Goal: (List.map f l).sum ≤ (List.map g l).sum
-- List.prod_le_prod'
@[to_additive sum_le_sum]
lemma prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i) :
    (l.map f).prod ≤ (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i)
Goal: (List.map f l).prod ≤ (List.map g l).prod
-- List.sum_lt_sum
@[to_additive sum_lt_sum]
lemma prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (f g : ι → M)
    (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} (f g : ι → M) (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i)
Goal: (List.map f l).sum < (List.map g l).sum
-- List.prod_lt_prod'
@[to_additive sum_lt_sum]
lemma prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (f g : ι → M)
    (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} (f g : ι → M) (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i)
Goal: (List.map f l).prod < (List.map g l).prod
-- List.prod_lt_prod_of_ne_nil
@[to_additive]
lemma prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
    (hlt : ∀ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} (hl : l ≠ []) (f g : ι → M) (hlt : ∀ i ∈ l, f i < g i)
Goal: (List.map f l).prod < (List.map g l).prod
-- List.sum_lt_sum_of_ne_nil
@[to_additive]
lemma prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
    (hlt : ∀ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} (hl : l ≠ []) (f g : ι → M) (hlt : ∀ i ∈ l, f i < g i)
Goal: (List.map f l).sum < (List.map g l).sum
-- List.sum_le_card_nsmul
@[to_additive sum_le_card_nsmul]
lemma prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
    l.prod ≤ n ^ l.length 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n)
Goal: l.sum ≤ l.length • n
-- List.prod_le_pow_card
@[to_additive sum_le_card_nsmul]
lemma prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
    l.prod ≤ n ^ l.length 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n)
Goal: l.prod ≤ n ^ l.length
-- List.card_nsmul_le_sum
@[to_additive card_nsmul_le_sum]
lemma pow_card_le_prod [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, n ≤ x) :
    n ^ l.length ≤ l.prod 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (l : List M) (n : M) (h : ∀ x ∈ l, n ≤ x)
Goal: l.length • n ≤ l.sum
-- List.pow_card_le_prod
@[to_additive card_nsmul_le_sum]
lemma pow_card_le_prod [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, n ≤ x) :
    n ^ l.length ≤ l.prod 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (l : List M) (n : M) (h : ∀ x ∈ l, n ≤ x)
Goal: n ^ l.length ≤ l.prod
-- List.exists_lt_of_sum_lt
@[to_additive exists_lt_of_sum_lt]
lemma exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
    (h : (l.map f).prod < (l.map g).prod) : ∃ i ∈ l, f i < g i 
Arguments: {ι : Type u_1} {M : Type u_3} [AddMonoid M] [LinearOrder M] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} (f g : ι → M) (h : (List.map f l).sum < (List.map g l).sum)
Goal: ∃ i ∈ l, f i < g i
-- List.exists_lt_of_prod_lt'
@[to_additive exists_lt_of_sum_lt]
lemma exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
    (h : (l.map f).prod < (l.map g).prod) : ∃ i ∈ l, f i < g i 
Arguments: {ι : Type u_1} {M : Type u_3} [Monoid M] [LinearOrder M] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} (f g : ι → M) (h : (List.map f l).prod < (List.map g l).prod)
Goal: ∃ i ∈ l, f i < g i
-- List.exists_le_of_prod_le'
@[to_additive exists_le_of_sum_le]
lemma exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
    (h : (l.map f).prod ≤ (l.map g).prod) : ∃ x ∈ l, f x ≤ g x 
Arguments: {ι : Type u_1} {M : Type u_3} [Monoid M] [LinearOrder M] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} (hl : l ≠ []) (f g : ι → M) (h : (List.map f l).prod ≤ (List.map g l).prod)
Goal: ∃ x ∈ l, f x ≤ g x
-- List.exists_le_of_sum_le
@[to_additive exists_le_of_sum_le]
lemma exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
    (h : (l.map f).prod ≤ (l.map g).prod) : ∃ x ∈ l, f x ≤ g x 
Arguments: {ι : Type u_1} {M : Type u_3} [AddMonoid M] [LinearOrder M] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List ι} (hl : l ≠ []) (f g : ι → M) (h : (List.map f l).sum ≤ (List.map g l).sum)
Goal: ∃ x ∈ l, f x ≤ g x
-- List.one_le_prod_of_one_le
@[to_additive sum_nonneg]
lemma one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod 
Arguments: {M : Type u_3} [Monoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List M} (hl₁ : ∀ x ∈ l, 1 ≤ x)
Goal: 1 ≤ l.prod
-- List.sum_nonneg
@[to_additive sum_nonneg]
lemma one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod 
Arguments: {M : Type u_3} [AddMonoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : List M} (hl₁ : ∀ x ∈ l, 0 ≤ x)
Goal: 0 ≤ l.sum
-- List.sum_le_foldr_max
lemma sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
    (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 
Arguments: {M : Type u_3} {N : Type u_4} [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0) (hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)) (l : List M)
Goal: f l.sum ≤ List.foldr max 0 (List.map f l)
-- List.sum_pos
@[to_additive sum_pos]
lemma one_lt_prod_of_one_lt [OrderedCommMonoid M] :
    ∀ l : List M, (∀ x ∈ l, (1 : M) < x) → l ≠ [] → 1 < l.prod
  
Arguments: {M : Type u_3} [OrderedAddCommMonoid M] (l : List M)
Goal: (∀ x ∈ l, 0 < x) → l ≠ [] → 0 < l.sum
-- List.one_lt_prod_of_one_lt
@[to_additive sum_pos]
lemma one_lt_prod_of_one_lt [OrderedCommMonoid M] :
    ∀ l : List M, (∀ x ∈ l, (1 : M) < x) → l ≠ [] → 1 < l.prod
  
Arguments: {M : Type u_3} [OrderedCommMonoid M] (l : List M)
Goal: (∀ x ∈ l, 1 < x) → l ≠ [] → 1 < l.prod
-- List.single_le_sum
@[to_additive]
lemma single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
    ∀ x ∈ l, x ≤ l.prod 
Arguments: {M : Type u_3} [OrderedAddCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, 0 ≤ x) (x : M)
Goal: x ∈ l → x ≤ l.sum
-- List.single_le_prod
@[to_additive]
lemma single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
    ∀ x ∈ l, x ≤ l.prod 
Arguments: {M : Type u_3} [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, 1 ≤ x) (x : M)
Goal: x ∈ l → x ≤ l.prod
-- List.all_one_of_le_one_le_of_prod_eq_one
@[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
lemma all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l) : x = 1 
Arguments: {M : Type u_3} [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, 1 ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l)
Goal: x = 1
-- List.all_zero_of_le_zero_le_of_sum_eq_zero
@[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
lemma all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l) : x = 1 
Arguments: {M : Type u_3} [OrderedAddCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, 0 ≤ x) (hl₂ : l.sum = 0) {x : M} (hx : x ∈ l)
Goal: x = 0
-- List.prod_eq_one_iff
@[to_additive] lemma prod_eq_one_iff : l.prod = 1 ↔ ∀ x ∈ l, x = (1 : M) 
Arguments: {M : Type u_3} [CanonicallyOrderedCommMonoid M] {l : List M}
Goal: l.prod = 1 ↔ ∀ x ∈ l, x = 1
-- List.sum_eq_zero_iff
@[to_additive] lemma prod_eq_one_iff : l.prod = 1 ↔ ∀ x ∈ l, x = (1 : M) 
Arguments: {M : Type u_3} [CanonicallyOrderedAddCommMonoid M] {l : List M}
Goal: l.sum = 0 ↔ ∀ x ∈ l, x = 0
-- List.monotone_prod_take
@[to_additive] lemma monotone_prod_take (L : List M) : Monotone fun i => (L.take i).prod 
Arguments: {M : Type u_3} [CanonicallyOrderedCommMonoid M] (L : List M)
Goal: Monotone fun i => (List.take i L).prod
-- List.monotone_sum_take
@[to_additive] lemma monotone_prod_take (L : List M) : Monotone fun i => (L.take i).prod 
Arguments: {M : Type u_3} [CanonicallyOrderedAddCommMonoid M] (L : List M)
Goal: Monotone fun i => (List.take i L).sum
-- Multiset.prod_nonneg
lemma prod_nonneg (h : ∀ a ∈ s, 0 ≤ a) : 0 ≤ s.prod 
Arguments: {R : Type u_1} [OrderedCommSemiring R] {s : Multiset R} (h : ∀ a ∈ s, 0 ≤ a)
Goal: 0 ≤ s.prod
-- CanonicallyOrderedCommSemiring.multiset_prod_pos
@[simp]
lemma _root_.CanonicallyOrderedCommSemiring.multiset_prod_pos [CanonicallyOrderedCommSemiring R]
    [Nontrivial R] {m : Multiset R} : 0 < m.prod ↔ ∀ x ∈ m, 0 < x 
Arguments: {R : Type u_1} [CanonicallyOrderedCommSemiring R] [Nontrivial R] {m : Multiset R}
Goal: 0 < m.prod ↔ ∀ x ∈ m, 0 < x
-- WithTop.coe_mul
@[simp, norm_cast] lemma coe_mul (a b : α) : (↑(a * b) : WithTop α) = a * b 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a b : α)
Goal: ↑(a * b) = ↑a * ↑b
-- WithTop.mul_top'
lemma mul_top' : ∀ (a : WithTop α), a * ⊤ = if a = 0 then 0 else ⊤
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a : WithTop α)
Goal: a * ⊤ = if a = 0 then 0 else ⊤
-- WithTop.mul_top
@[simp] lemma mul_top (h : a ≠ 0) : a * ⊤ = ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {a : WithTop α} (h : a ≠ 0)
Goal: a * ⊤ = ⊤
-- WithTop.top_mul'
lemma top_mul' : ∀ (b : WithTop α), ⊤ * b = if b = 0 then 0 else ⊤
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (b : WithTop α)
Goal: ⊤ * b = if b = 0 then 0 else ⊤
-- WithTop.top_mul
@[simp] lemma top_mul (hb : b ≠ 0) : ⊤ * b = ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {b : WithTop α} (hb : b ≠ 0)
Goal: ⊤ * b = ⊤
-- WithTop.top_mul_top
@[simp] lemma top_mul_top : (⊤ * ⊤ : WithTop α) = ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α]
Goal: ⊤ * ⊤ = ⊤
-- WithTop.mul_def
lemma mul_def (a b : WithTop α) :
    a * b = if a = 0 ∨ b = 0 then 0 else WithTop.map₂ (· * ·) a b 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a b : WithTop α)
Goal: a * b = if a = 0 ∨ b = 0 then 0 else WithTop.map₂ (fun x x_1 => x * x_1) a b
-- WithTop.mul_eq_top_iff
lemma mul_eq_top_iff : a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {a b : WithTop α}
Goal: a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0
-- WithTop.mul_coe_eq_bind
lemma mul_coe_eq_bind {b : α} (hb : b ≠ 0) : ∀ a, (a * b : WithTop α) = a.bind fun a ↦ ↑(a * b)
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {b : α} (hb : b ≠ 0) (a : WithTop α)
Goal: a * ↑b = Option.bind a fun a => some (a * b)
-- WithTop.coe_mul_eq_bind
lemma coe_mul_eq_bind {a : α} (ha : a ≠ 0) : ∀ b, (a * b : WithTop α) = b.bind fun b ↦ ↑(a * b)
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {a : α} (ha : a ≠ 0) (b : WithTop α)
Goal: ↑a * b = Option.bind b fun b => some (a * b)
-- WithTop.untop'_zero_mul
@[simp] lemma untop'_zero_mul (a b : WithTop α) : (a * b).untop' 0 = a.untop' 0 * b.untop' 0 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a b : WithTop α)
Goal: WithTop.untop' 0 (a * b) = WithTop.untop' 0 a * WithTop.untop' 0 b
-- WithTop.mul_lt_top'
theorem mul_lt_top' [LT α] {a b : WithTop α} (ha : a < ⊤) (hb : b < ⊤) : a * b < ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] [LT α] {a b : WithTop α} (ha : a < ⊤) (hb : b < ⊤)
Goal: a * b < ⊤
-- WithTop.mul_lt_top
theorem mul_lt_top [LT α] {a b : WithTop α} (ha : a ≠ ⊤) (hb : b ≠ ⊤) : a * b < ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] [LT α] {a b : WithTop α} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a * b < ⊤
-- MonoidWithZeroHom.withTopMap_apply
@[simps (config := .asFn)]
protected def _root_.MonoidWithZeroHom.withTopMap {R S : Type*} [MulZeroOneClass R] [DecidableEq R]
    [Nontrivial R] [MulZeroOneClass S] [DecidableEq S] [Nontrivial S] (f : R →*₀ S)
    (hf : Function.Injective f) : WithTop R →*₀ WithTop S 
Arguments: {R : Type u_2} {S : Type u_3} [MulZeroOneClass R] [DecidableEq R] [Nontrivial R] [MulZeroOneClass S] [DecidableEq S] [Nontrivial S] (f : R →*₀ S) (hf : Function.Injective ⇑f)
Goal: ⇑(f.withTopMap hf) = WithTop.map ⇑f
-- WithTop.coe_pow
@[simp, norm_cast] lemma coe_pow (a : α) (n : ℕ) : (↑(a ^ n) : WithTop α) = a ^ n 
Arguments: {α : Type u_1} [DecidableEq α] [MonoidWithZero α] [NoZeroDivisors α] [Nontrivial α] (a : α) (n : ℕ)
Goal: ↑(a ^ n) = ↑a ^ n
-- WithTop.top_pow
theorem top_pow {n : ℕ} (n_pos : 0 < n) : (⊤ : WithTop α) ^ n = ⊤ 
Arguments: {α : Type u_1} [DecidableEq α] [MonoidWithZero α] [NoZeroDivisors α] [Nontrivial α] {n : ℕ} (n_pos : 0 < n)
Goal: ⊤ ^ n = ⊤
-- _private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.distrib'
private theorem distrib' (a b c : WithTop α) : (a + b) * c = a * c + b * c 
Arguments: {α : Type u_1} [DecidableEq α] [CanonicallyOrderedCommSemiring α] (a b c : WithTop α)
Goal: (a + b) * c = a * c + b * c
-- RingHom.withTopMap_apply
@[simps (config := .asFn)]
protected def _root_.RingHom.withTopMap {R S : Type*} [CanonicallyOrderedCommSemiring R]
    [DecidableEq R] [Nontrivial R] [CanonicallyOrderedCommSemiring S] [DecidableEq S] [Nontrivial S]
    (f : R →+* S) (hf : Function.Injective f) : WithTop R →+* WithTop S 
Arguments: {R : Type u_2} {S : Type u_3} [CanonicallyOrderedCommSemiring R] [DecidableEq R] [Nontrivial R] [CanonicallyOrderedCommSemiring S] [DecidableEq S] [Nontrivial S] (f : R →+* S) (hf : Function.Injective ⇑f)
Goal: ⇑(f.withTopMap hf) = (↑(f.toMonoidWithZeroHom.withTopMap hf)).toFun
-- WithBot.coe_mul
@[simp, norm_cast] lemma coe_mul (a b : α) : (↑(a * b) : WithBot α) = a * b 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a b : α)
Goal: ↑(a * b) = ↑a * ↑b
-- WithBot.mul_bot'
lemma mul_bot' : ∀ (a : WithBot α), a * ⊥ = if a = 0 then 0 else ⊥
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a : WithBot α)
Goal: a * ⊥ = if a = 0 then 0 else ⊥
-- WithBot.mul_bot
@[simp] lemma mul_bot (h : a ≠ 0) : a * ⊥ = ⊥ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {a : WithBot α} (h : a ≠ 0)
Goal: a * ⊥ = ⊥
-- WithBot.bot_mul'
lemma bot_mul' : ∀ (b : WithBot α), ⊥ * b = if b = 0 then 0 else ⊥
  
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (b : WithBot α)
Goal: ⊥ * b = if b = 0 then 0 else ⊥
-- WithBot.bot_mul
@[simp] lemma bot_mul (hb : b ≠ 0) : ⊥ * b = ⊥ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] {b : WithBot α} (hb : b ≠ 0)
Goal: ⊥ * b = ⊥
-- WithBot.bot_mul_bot
@[simp] lemma bot_mul_bot : (⊥ * ⊥ : WithBot α) = ⊥ 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α]
Goal: ⊥ * ⊥ = ⊥
-- WithBot.mul_def
lemma mul_def (a b : WithBot α) :
    a * b = if a = 0 ∨ b = 0 then 0 else WithBot.map₂ (· * ·) a b 
Arguments: {α : Type u_1} [DecidableEq α] [MulZeroClass α] (a b : WithBot α)
Goal: a * b = if a = 0 ∨ b = 0 then 0 else WithBot.map₂ (fun x x_1 => x * x_1) a b