ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AList.lookupFinsupp_support
@[simp]
theorem lookupFinsupp_support [DecidableEq α] [DecidableEq M] (l : AList fun _x : α => M) :
    l.lookupFinsupp.support = (l.1.filter fun x => Sigma.snd x ≠ 0).keys.toFinset 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] [DecidableEq α] [DecidableEq M] (l : AList fun _x => M)
Goal: l.lookupFinsupp.support = (List.filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset
-- AList.lookupFinsupp_eq_iff_of_ne_zero
theorem lookupFinsupp_eq_iff_of_ne_zero [DecidableEq α] {l : AList fun _x : α => M} {a : α} {x : M}
    (hx : x ≠ 0) : l.lookupFinsupp a = x ↔ x ∈ l.lookup a 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] [DecidableEq α] {l : AList fun _x => M} {a : α} {x : M} (hx : x ≠ 0)
Goal: l.lookupFinsupp a = x ↔ x ∈ AList.lookup a l
-- AList.lookupFinsupp_eq_zero_iff
theorem lookupFinsupp_eq_zero_iff [DecidableEq α] {l : AList fun _x : α => M} {a : α} :
    l.lookupFinsupp a = 0 ↔ a ∉ l ∨ (0 : M) ∈ l.lookup a 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] [DecidableEq α] {l : AList fun _x => M} {a : α}
Goal: l.lookupFinsupp a = 0 ↔ a ∉ l ∨ 0 ∈ AList.lookup a l
-- AList.empty_lookupFinsupp
@[simp]
theorem empty_lookupFinsupp : lookupFinsupp (∅ : AList fun _x : α => M) = 0 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M]
Goal: ∅.lookupFinsupp = 0
-- AList.insert_lookupFinsupp
@[simp]
theorem insert_lookupFinsupp [DecidableEq α] (l : AList fun _x : α => M) (a : α) (m : M) :
    (l.insert a m).lookupFinsupp = l.lookupFinsupp.update a m 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] [DecidableEq α] (l : AList fun _x => M) (a : α) (m : M)
Goal: (AList.insert a m l).lookupFinsupp = l.lookupFinsupp.update a m
-- AList.singleton_lookupFinsupp
@[simp]
theorem singleton_lookupFinsupp (a : α) (m : M) :
    (singleton a m).lookupFinsupp = Finsupp.single a m 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] (a : α) (m : M)
Goal: (AList.singleton a m).lookupFinsupp = Finsupp.single a m
-- Finsupp.toAList_lookupFinsupp
@[simp]
theorem _root_.Finsupp.toAList_lookupFinsupp (f : α →₀ M) : f.toAList.lookupFinsupp = f 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M] (f : α →₀ M)
Goal: f.toAList.lookupFinsupp = f
-- AList.lookupFinsupp_surjective
theorem lookupFinsupp_surjective : Function.Surjective (@lookupFinsupp α M _) 
Arguments: {α : Type u_1} {M : Type u_2} [Zero M]
Goal: Function.Surjective AList.lookupFinsupp
-- Pi.lex_eq_dfinsupp_lex
theorem _root_.Pi.lex_eq_dfinsupp_lex {r : ι → ι → Prop} {s : ∀ i, α i → α i → Prop}
    (a b : Π₀ i, α i) : Pi.Lex r (s _) (a : ∀ i, α i) b = DFinsupp.Lex r s a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (a b : Π₀ (i : ι), α i)
Goal: Pi.Lex r (fun {i} => s i) ⇑a ⇑b = DFinsupp.Lex r s a b
-- DFinsupp.lex_def
theorem lex_def {r : ι → ι → Prop} {s : ∀ i, α i → α i → Prop} {a b : Π₀ i, α i} :
    DFinsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s j (a j) (b j) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} {a b : Π₀ (i : ι), α i}
Goal: DFinsupp.Lex r s a b ↔ ∃ j, (∀ (d : ι), r d j → a d = b d) ∧ s j (a j) (b j)
-- DFinsupp.lex_lt_of_lt_of_preorder
theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (α i)] (r) [IsStrictOrder ι r] {x y : Π₀ i, α i}
    (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] [(i : ι) → Preorder (α i)] (r : ι → ι → Prop) [IsStrictOrder ι r] {x y : Π₀ (i : ι), α i} (hlt : x < y)
Goal: ∃ i, (∀ (j : ι), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
-- DFinsupp.lex_lt_of_lt
theorem lex_lt_of_lt [∀ i, PartialOrder (α i)] (r) [IsStrictOrder ι r] {x y : Π₀ i, α i}
    (hlt : x < y) : Pi.Lex r (· < ·) x y 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] [(i : ι) → PartialOrder (α i)] (r : ι → ι → Prop) [IsStrictOrder ι r] {x y : Π₀ (i : ι), α i} (hlt : x < y)
Goal: Pi.Lex r (fun {i} x x_1 => x < x_1) ⇑x ⇑y
-- DFinsupp.Lex.decidableLE_def
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·) 
Arguments: {ι : Type u_3} {α : ι → Type u_4} [(i : ι) → Zero (α i)] [LinearOrder ι] [(i : ι) → LinearOrder (α i)]
Goal: DFinsupp.Lex.decidableLE =
  DFinsupp.lt_trichotomy_rec (fun {f g} h => isTrue ⋯) (fun {f g} h => isTrue ⋯) fun {f g} h => isFalse ⋯
-- DFinsupp.Lex.decidableLT_def
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·) 
Arguments: {ι : Type u_3} {α : ι → Type u_4} [(i : ι) → Zero (α i)] [LinearOrder ι] [(i : ι) → LinearOrder (α i)]
Goal: DFinsupp.Lex.decidableLT =
  DFinsupp.lt_trichotomy_rec (fun {f g} h => isTrue h) (fun {f g} h => isFalse ⋯) fun {f g} h => isFalse ⋯
-- DFinsupp.toLex_monotone
theorem toLex_monotone : Monotone (@toLex (Π₀ i, α i)) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] [LinearOrder ι] [(i : ι) → PartialOrder (α i)]
Goal: Monotone ⇑toLex
-- DFinsupp.lt_of_forall_lt_of_lt
theorem lt_of_forall_lt_of_lt (a b : Lex (Π₀ i, α i)) (i : ι) :
    (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] [LinearOrder ι] [(i : ι) → PartialOrder (α i)] (a b : Lex (Π₀ (i : ι), α i)) (i : ι)
Goal: (∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b
-- List.support_sum_subset
theorem List.support_sum_subset [AddMonoid M] (l : List (ι →₀ M)) :
    l.sum.support ⊆ l.foldr (Finsupp.support · ⊔ ·) ∅ 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddMonoid M] (l : List (ι →₀ M))
Goal: l.sum.support ⊆ List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l
-- Multiset.support_sum_subset
theorem Multiset.support_sum_subset [AddCommMonoid M] (s : Multiset (ι →₀ M)) :
    s.sum.support ⊆ (s.map Finsupp.support).sup 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddCommMonoid M] (s : Multiset (ι →₀ M))
Goal: s.sum.support ⊆ (Multiset.map Finsupp.support s).sup
-- Finset.support_sum_subset
theorem Finset.support_sum_subset [AddCommMonoid M] (s : Finset (ι →₀ M)) :
    (s.sum id).support ⊆ Finset.sup s Finsupp.support 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddCommMonoid M] (s : Finset (ι →₀ M))
Goal: (s.sum id).support ⊆ s.sup Finsupp.support
-- List.mem_foldr_sup_support_iff
theorem List.mem_foldr_sup_support_iff [Zero M] {l : List (ι →₀ M)} {x : ι} :
    x ∈ l.foldr (Finsupp.support · ⊔ ·) ∅ ↔ ∃ f ∈ l, x ∈ f.support 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [Zero M] {l : List (ι →₀ M)} {x : ι}
Goal: x ∈ List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l ↔ ∃ f ∈ l, x ∈ f.support
-- Multiset.mem_sup_map_support_iff
theorem Multiset.mem_sup_map_support_iff [Zero M] {s : Multiset (ι →₀ M)} {x : ι} :
    x ∈ (s.map Finsupp.support).sup ↔ ∃ f ∈ s, x ∈ f.support 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [Zero M] {s : Multiset (ι →₀ M)} {x : ι}
Goal: x ∈ (Multiset.map Finsupp.support s).sup ↔ ∃ f ∈ s, x ∈ f.support
-- Finset.mem_sup_support_iff
theorem Finset.mem_sup_support_iff [Zero M] {s : Finset (ι →₀ M)} {x : ι} :
    x ∈ s.sup Finsupp.support ↔ ∃ f ∈ s, x ∈ f.support 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [Zero M] {s : Finset (ι →₀ M)} {x : ι}
Goal: x ∈ s.sup Finsupp.support ↔ ∃ f ∈ s, x ∈ f.support
-- List.support_sum_eq
theorem List.support_sum_eq [AddMonoid M] (l : List (ι →₀ M))
    (hl : l.Pairwise (_root_.Disjoint on Finsupp.support)) :
    l.sum.support = l.foldr (Finsupp.support · ⊔ ·) ∅ 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddMonoid M] (l : List (ι →₀ M)) (hl : List.Pairwise (Disjoint on Finsupp.support) l)
Goal: l.sum.support = List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l
-- Multiset.support_sum_eq
theorem Multiset.support_sum_eq [AddCommMonoid M] (s : Multiset (ι →₀ M))
    (hs : s.Pairwise (_root_.Disjoint on Finsupp.support)) :
    s.sum.support = (s.map Finsupp.support).sup 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddCommMonoid M] (s : Multiset (ι →₀ M)) (hs : Multiset.Pairwise (Disjoint on Finsupp.support) s)
Goal: s.sum.support = (Multiset.map Finsupp.support s).sup
-- Finset.support_sum_eq
theorem Finset.support_sum_eq [AddCommMonoid M] (s : Finset (ι →₀ M))
    (hs : (s : Set (ι →₀ M)).PairwiseDisjoint Finsupp.support) :
    (s.sum id).support = Finset.sup s Finsupp.support 
Arguments: {ι : Type u_1} {M : Type u_2} [DecidableEq ι] [AddCommMonoid M] (s : Finset (ι →₀ M)) (hs : (↑s).PairwiseDisjoint Finsupp.support)
Goal: (s.sum id).support = s.sup Finsupp.support
-- Finsupp.mem_neLocus
@[simp]
theorem mem_neLocus {f g : α →₀ N} {a : α} : a ∈ f.neLocus g ↔ f a ≠ g a 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] {f g : α →₀ N} {a : α}
Goal: a ∈ f.neLocus g ↔ f a ≠ g a
-- Finsupp.not_mem_neLocus
theorem not_mem_neLocus {f g : α →₀ N} {a : α} : a ∉ f.neLocus g ↔ f a = g a 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] {f g : α →₀ N} {a : α}
Goal: a ∉ f.neLocus g ↔ f a = g a
-- Finsupp.coe_neLocus
@[simp]
theorem coe_neLocus : ↑(f.neLocus g) = { x | f x ≠ g x } 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] (f g : α →₀ N)
Goal: ↑(f.neLocus g) = {x | f x ≠ g x}
-- Finsupp.neLocus_eq_empty
@[simp]
theorem neLocus_eq_empty {f g : α →₀ N} : f.neLocus g = ∅ ↔ f = g 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] {f g : α →₀ N}
Goal: f.neLocus g = ∅ ↔ f = g
-- Finsupp.nonempty_neLocus_iff
@[simp]
theorem nonempty_neLocus_iff {f g : α →₀ N} : (f.neLocus g).Nonempty ↔ f ≠ g 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] {f g : α →₀ N}
Goal: (f.neLocus g).Nonempty ↔ f ≠ g
-- Finsupp.neLocus_comm
theorem neLocus_comm : f.neLocus g = g.neLocus f 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] (f g : α →₀ N)
Goal: f.neLocus g = g.neLocus f
-- Finsupp.neLocus_zero_right
@[simp]
theorem neLocus_zero_right : f.neLocus 0 = f.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] (f : α →₀ N)
Goal: f.neLocus 0 = f.support
-- Finsupp.neLocus_zero_left
@[simp]
theorem neLocus_zero_left : (0 : α →₀ N).neLocus f = f.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] (f : α →₀ N)
Goal: Finsupp.neLocus 0 f = f.support
-- Finsupp.subset_mapRange_neLocus
theorem subset_mapRange_neLocus [DecidableEq N] [Zero N] [DecidableEq M] [Zero M] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) : (f.mapRange F F0).neLocus (g.mapRange F F0) ⊆ f.neLocus g 
Arguments: {α : Type u_1} {M : Type u_2} {N : Type u_3} [DecidableEq α] [DecidableEq N] [Zero N] [DecidableEq M] [Zero M] (f g : α →₀ N) {F : N → M} (F0 : F 0 = 0)
Goal: (Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) ⊆ f.neLocus g
-- Finsupp.zipWith_neLocus_eq_left
theorem zipWith_neLocus_eq_left [DecidableEq N] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f : α →₀ M) (g₁ g₂ : α →₀ N)
    (hF : ∀ f, Function.Injective fun g => F f g) :
    (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂ 
Arguments: {α : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [DecidableEq α] [DecidableEq N] [Zero M] [DecidableEq P] [Zero P] [Zero N] {F : M → N → P} (F0 : F 0 0 = 0) (f : α →₀ M) (g₁ g₂ : α →₀ N) (hF : ∀ (f : M), Function.Injective fun g => F f g)
Goal: (Finsupp.zipWith F F0 f g₁).neLocus (Finsupp.zipWith F F0 f g₂) = g₁.neLocus g₂
-- Finsupp.zipWith_neLocus_eq_right
theorem zipWith_neLocus_eq_right [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N)
    (hF : ∀ g, Function.Injective fun f => F f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂ 
Arguments: {α : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [DecidableEq α] [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N] {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N) (hF : ∀ (g : N), Function.Injective fun f => F f g)
Goal: (Finsupp.zipWith F F0 f₁ g).neLocus (Finsupp.zipWith F F0 f₂ g) = f₁.neLocus f₂
-- Finsupp.mapRange_neLocus_eq
theorem mapRange_neLocus_eq [DecidableEq N] [DecidableEq M] [Zero M] [Zero N] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) (hF : Function.Injective F) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) = f.neLocus g 
Arguments: {α : Type u_1} {M : Type u_2} {N : Type u_3} [DecidableEq α] [DecidableEq N] [DecidableEq M] [Zero M] [Zero N] (f g : α →₀ N) {F : N → M} (F0 : F 0 = 0) (hF : Function.Injective F)
Goal: (Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) = f.neLocus g
-- Finsupp.neLocus_add_left
@[simp]
theorem neLocus_add_left [AddLeftCancelMonoid N] (f g h : α →₀ N) :
    (f + g).neLocus (f + h) = g.neLocus h 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddLeftCancelMonoid N] (f g h : α →₀ N)
Goal: (f + g).neLocus (f + h) = g.neLocus h
-- Finsupp.neLocus_add_right
@[simp]
theorem neLocus_add_right [AddRightCancelMonoid N] (f g h : α →₀ N) :
    (f + h).neLocus (g + h) = f.neLocus g 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddRightCancelMonoid N] (f g h : α →₀ N)
Goal: (f + h).neLocus (g + h) = f.neLocus g
-- Finsupp.neLocus_neg_neg
@[simp]
theorem neLocus_neg_neg : neLocus (-f) (-g) = f.neLocus g 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: (-f).neLocus (-g) = f.neLocus g
-- Finsupp.neLocus_neg
theorem neLocus_neg : neLocus (-f) g = f.neLocus (-g) 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: (-f).neLocus g = f.neLocus (-g)
-- Finsupp.neLocus_eq_support_sub
theorem neLocus_eq_support_sub : f.neLocus g = (f - g).support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: f.neLocus g = (f - g).support
-- Finsupp.neLocus_sub_left
@[simp]
theorem neLocus_sub_left : neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂ 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g₁ g₂ : α →₀ N)
Goal: (f - g₁).neLocus (f - g₂) = g₁.neLocus g₂
-- Finsupp.neLocus_sub_right
@[simp]
theorem neLocus_sub_right : neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂ 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f₁ f₂ g : α →₀ N)
Goal: (f₁ - g).neLocus (f₂ - g) = f₁.neLocus f₂
-- Finsupp.neLocus_self_add_right
@[simp]
theorem neLocus_self_add_right : neLocus f (f + g) = g.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: f.neLocus (f + g) = g.support
-- Finsupp.neLocus_self_add_left
@[simp]
theorem neLocus_self_add_left : neLocus (f + g) f = g.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: (f + g).neLocus f = g.support
-- Finsupp.neLocus_self_sub_right
@[simp]
theorem neLocus_self_sub_right : neLocus f (f - g) = g.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: f.neLocus (f - g) = g.support
-- Finsupp.neLocus_self_sub_left
@[simp]
theorem neLocus_self_sub_left : neLocus (f - g) f = g.support 
Arguments: {α : Type u_1} {N : Type u_3} [DecidableEq α] [DecidableEq N] [AddGroup N] (f g : α →₀ N)
Goal: (f - g).neLocus f = g.support
-- Finsupp.Lex.acc
theorem Lex.acc (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s) (x : α →₀ N)
    (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) a) :
    Acc (Finsupp.Lex r s) x 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : ∀ ⦃n : N⦄, ¬s n 0) (hs : WellFounded s) (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a)
Goal: Acc (Finsupp.Lex r s) x
-- Finsupp.Lex.wellFounded
theorem Lex.wellFounded (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s)
    (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : ∀ ⦃n : N⦄, ¬s n 0) (hs : WellFounded s) (hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1))
Goal: WellFounded (Finsupp.Lex r s)
-- Finsupp.Lex.wellFounded'
theorem Lex.wellFounded' (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s)
    [IsTrichotomous α r] (hr : WellFounded (Function.swap r)) : WellFounded (Finsupp.Lex r s) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : ∀ ⦃n : N⦄, ¬s n 0) (hs : WellFounded s) [IsTrichotomous α r] (hr : WellFounded (Function.swap r))
Goal: WellFounded (Finsupp.Lex r s)
-- Finsupp.Lex.wellFounded_of_finite
theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α]
    (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] (r : α → α → Prop) {s : N → N → Prop} [IsStrictTotalOrder α r] [Finite α] (hs : WellFounded s)
Goal: WellFounded (Finsupp.Lex r s)
-- Finsupp.Lex.wellFoundedLT_of_finite
theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [LT N]
    [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [LinearOrder α] [Finite α] [LT N] [hwf : WellFoundedLT N]
Goal: WellFoundedLT (Lex (α →₀ N))
-- Finsupp.wellFoundedLT
protected theorem wellFoundedLT [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
    WellFoundedLT (α →₀ N) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ (n : N), ¬n < 0)
Goal: WellFoundedLT (α →₀ N)
-- Finsupp.weight_apply
theorem weight_apply (f : σ →₀ ℕ) :
    weight w f = Finsupp.sum f (fun i c => c • w i) 
Arguments: {σ : Type u_1} {M : Type u_2} (w : σ → M) [AddCommMonoid M] (f : σ →₀ ℕ)
Goal: (Finsupp.weight w) f = f.sum fun i c => c • w i
-- Finsupp.NonTorsionWeight.eq_zero_of_smul_eq_zero
class NonTorsionWeight (w : σ → M) : Prop where
  eq_zero_of_smul_eq_zero {n : ℕ} {s : σ} (h : n • w s = 0)  : n = 0
Arguments: {σ : Type u_1} {M : Type u_2} [AddCommMonoid M] {w : σ → M} [self : Finsupp.NonTorsionWeight w] {n : ℕ} {s : σ} (h : n • w s = 0)
Goal: n = 0
-- Finsupp.nonTorsionWeight_of
theorem nonTorsionWeight_of [NoZeroSMulDivisors ℕ M] (hw : ∀ i : σ, w i ≠ 0) :
    NonTorsionWeight w 
Arguments: {σ : Type u_1} {M : Type u_2} (w : σ → M) [AddCommMonoid M] [NoZeroSMulDivisors ℕ M] (hw : ∀ (i : σ), w i ≠ 0)
Goal: Finsupp.NonTorsionWeight w
-- Finsupp.NonTorsionWeight.ne_zero
theorem NonTorsionWeight.ne_zero [NonTorsionWeight w] (s : σ) :
    w s ≠ 0 
Arguments: {σ : Type u_1} {M : Type u_2} (w : σ → M) [AddCommMonoid M] [Finsupp.NonTorsionWeight w] (s : σ)
Goal: w s ≠ 0
-- Finsupp.le_weight
theorem le_weight (w : σ → ℕ) {s : σ} (hs : w s ≠ 0) (f : σ →₀ ℕ) :
    f s ≤ weight w f 
Arguments: {σ : Type u_1} (w : σ → ℕ) {s : σ} (hs : w s ≠ 0) (f : σ →₀ ℕ)
Goal: f s ≤ (Finsupp.weight w) f
-- Finsupp.le_weight_of_ne_zero
theorem le_weight_of_ne_zero (hw : ∀ s, 0 ≤ w s) {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0) :
    w s ≤ weight w f 
Arguments: {σ : Type u_1} {M : Type u_2} [OrderedAddCommMonoid M] (w : σ → M) (hw : ∀ (s : σ), 0 ≤ w s) {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0)
Goal: w s ≤ (Finsupp.weight w) f
-- Finsupp.le_weight_of_ne_zero'
theorem le_weight_of_ne_zero' {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0) :
    w s ≤ weight w f 
Arguments: {σ : Type u_1} {M : Type u_3} [CanonicallyOrderedAddCommMonoid M] (w : σ → M) {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0)
Goal: w s ≤ (Finsupp.weight w) f
-- Finsupp.weight_eq_zero_iff_eq_zero
theorem weight_eq_zero_iff_eq_zero
    (w : σ → M) [NonTorsionWeight w] {f : σ →₀ ℕ} :
    weight w f = 0 ↔ f = 0 
Arguments: {σ : Type u_1} {M : Type u_3} [CanonicallyOrderedAddCommMonoid M] (w : σ → M) [Finsupp.NonTorsionWeight w] {f : σ →₀ ℕ}
Goal: (Finsupp.weight w) f = 0 ↔ f = 0
-- Finsupp.degree_eq_zero_iff
lemma degree_eq_zero_iff (d : σ →₀ ℕ) : degree d = 0 ↔ d = 0 
Arguments: {σ : Type u_1} (d : σ →₀ ℕ)
Goal: d.degree = 0 ↔ d = 0
-- Finsupp.degree_zero
@[simp]
theorem degree_zero : degree (0 : σ →₀ ℕ) = 0 
Arguments: {σ : Type u_1}
Goal: Finsupp.degree 0 = 0
-- Finsupp.degree_eq_weight_one
theorem degree_eq_weight_one :
    degree (σ := σ) = weight 1 
Arguments: {σ : Type u_1}
Goal: Finsupp.degree = ⇑(Finsupp.weight 1)
-- Finsupp.le_degree
theorem le_degree (s : σ) (f : σ →₀ ℕ) : f s ≤ degree f  
Arguments: {σ : Type u_1} (s : σ) (f : σ →₀ ℕ)
Goal: f s ≤ f.degree
-- EReal.coe_strictMono
theorem coe_strictMono : StrictMono Real.toEReal 
Goal: StrictMono Real.toEReal
-- EReal.coe_injective
theorem coe_injective : Injective Real.toEReal 
Goal: Function.Injective Real.toEReal
-- EReal.coe_le_coe_iff
@[simp, norm_cast]
protected theorem coe_le_coe_iff {x y : ℝ} : (x : EReal) ≤ (y : EReal) ↔ x ≤ y 
Arguments: {x y : ℝ}
Goal: ↑x ≤ ↑y ↔ x ≤ y
-- EReal.coe_lt_coe_iff
@[simp, norm_cast]
protected theorem coe_lt_coe_iff {x y : ℝ} : (x : EReal) < (y : EReal) ↔ x < y 
Arguments: {x y : ℝ}
Goal: ↑x < ↑y ↔ x < y
-- EReal.coe_eq_coe_iff
@[simp, norm_cast]
protected theorem coe_eq_coe_iff {x y : ℝ} : (x : EReal) = (y : EReal) ↔ x = y 
Arguments: {x y : ℝ}
Goal: ↑x = ↑y ↔ x = y
-- EReal.coe_ne_coe_iff
protected theorem coe_ne_coe_iff {x y : ℝ} : (x : EReal) ≠ (y : EReal) ↔ x ≠ y 
Arguments: {x y : ℝ}
Goal: ↑x ≠ ↑y ↔ x ≠ y
-- EReal.coe_zero
@[simp, norm_cast]
theorem coe_zero : ((0 : ℝ) : EReal) = 0 
Goal: ↑0 = 0
-- EReal.coe_one
@[simp, norm_cast]
theorem coe_one : ((1 : ℝ) : EReal) = 1 
Goal: ↑1 = 1
-- EReal.coe_mul
@[simp, norm_cast]
theorem coe_mul (x y : ℝ) : (↑(x * y) : EReal) = x * y 
Arguments: (x y : ℝ)
Goal: ↑(x * y) = ↑x * ↑y
-- EReal.induction₂
@[elab_as_elim]
theorem induction₂ {P : EReal → EReal → Prop} (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x)
    (top_zero : P ⊤ 0) (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥)
    (pos_top : ∀ x : ℝ, 0 < x → P x ⊤) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥) (zero_top : P 0 ⊤)
    (coe_coe : ∀ x y : ℝ, P x y) (zero_bot : P 0 ⊥) (neg_top : ∀ x : ℝ, x < 0 → P x ⊤)
    (neg_bot : ∀ x : ℝ, x < 0 → P x ⊥) (bot_top : P ⊥ ⊤) (bot_pos : ∀ x : ℝ, 0 < x → P ⊥ x)
    (bot_zero : P ⊥ 0) (bot_neg : ∀ x : ℝ, x < 0 → P ⊥ x) (bot_bot : P ⊥ ⊥) : ∀ x y, P x y
  
Arguments: {P : EReal → EReal → Prop} (top_top : P ⊤ ⊤) (top_pos : ∀ (x : ℝ), 0 < x → P ⊤ ↑x) (top_zero : P ⊤ 0) (top_neg : ∀ x < 0, P ⊤ ↑x) (top_bot : P ⊤ ⊥) (pos_top : ∀ (x : ℝ), 0 < x → P ↑x ⊤) (pos_bot : ∀ (x : ℝ), 0 < x → P ↑x ⊥) (zero_top : P 0 ⊤) (coe_coe : ∀ (x y : ℝ), P ↑x ↑y) (zero_bot : P 0 ⊥) (neg_top : ∀ x < 0, P ↑x ⊤) (neg_bot : ∀ x < 0, P ↑x ⊥) (bot_top : P ⊥ ⊤) (bot_pos : ∀ (x : ℝ), 0 < x → P ⊥ ↑x) (bot_zero : P ⊥ 0) (bot_neg : ∀ x < 0, P ⊥ ↑x) (bot_bot : P ⊥ ⊥) (x y : EReal)
Goal: P x y
-- EReal.induction₂_symm
@[elab_as_elim]
theorem induction₂_symm {P : EReal → EReal → Prop} (symm : ∀ {x y}, P x y → P y x)
    (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x) (top_zero : P ⊤ 0)
    (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥)
    (coe_coe : ∀ x y : ℝ, P x y) (zero_bot : P 0 ⊥) (neg_bot : ∀ x : ℝ, x < 0 → P x ⊥)
    (bot_bot : P ⊥ ⊥) : ∀ x y, P x y 
Arguments: {P : EReal → EReal → Prop} (symm : ∀ {x y : EReal}, P x y → P y x) (top_top : P ⊤ ⊤) (top_pos : ∀ (x : ℝ), 0 < x → P ⊤ ↑x) (top_zero : P ⊤ 0) (top_neg : ∀ x < 0, P ⊤ ↑x) (top_bot : P ⊤ ⊥) (pos_bot : ∀ (x : ℝ), 0 < x → P ↑x ⊥) (coe_coe : ∀ (x y : ℝ), P ↑x ↑y) (zero_bot : P 0 ⊥) (neg_bot : ∀ x < 0, P ↑x ⊥) (bot_bot : P ⊥ ⊥) (x y : EReal)
Goal: P x y
-- EReal.mul_comm
protected theorem mul_comm (x y : EReal) : x * y = y * x 
Arguments: (x y : EReal)
Goal: x * y = y * x
-- EReal.one_mul
protected theorem one_mul : ∀ x : EReal, 1 * x = x
  
Arguments: (x : EReal)
Goal: 1 * x = x
-- EReal.zero_mul
protected theorem zero_mul : ∀ x : EReal, 0 * x = 0
  
Arguments: (x : EReal)
Goal: 0 * x = 0
-- EReal.toReal_top
@[simp]
theorem toReal_top : toReal ⊤ = 0 
Goal: ⊤.toReal = 0
-- EReal.toReal_bot
@[simp]
theorem toReal_bot : toReal ⊥ = 0 
Goal: ⊥.toReal = 0
-- EReal.toReal_zero
@[simp]
theorem toReal_zero : toReal 0 = 0 
Goal: EReal.toReal 0 = 0
-- EReal.toReal_one
@[simp]
theorem toReal_one : toReal 1 = 1 
Goal: EReal.toReal 1 = 1
-- EReal.toReal_coe
@[simp]
theorem toReal_coe (x : ℝ) : toReal (x : EReal) = x 
Arguments: (x : ℝ)
Goal: (↑x).toReal = x
-- EReal.bot_lt_coe
@[simp]
theorem bot_lt_coe (x : ℝ) : (⊥ : EReal) < x 
Arguments: (x : ℝ)
Goal: ⊥ < ↑x