ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Finsupp/AList.lean

full_name: Finsupp.toAList
code: /-- Produce an association list for the finsupp over its support using choice. -/
@[simps]
noncomputable def toAList (f : α →₀ M) : AList fun _x : α => M 
goal: AList fun _x => M

full_name: Finsupp.toAList_entries
code: /-- Produce an association list for the finsupp over its support using choice. -/
@[simps]
noncomputable def toAList (f : α →₀ M) : AList fun _x : α => M 
goal: f.toAList.entries = List.map Prod.toSigma f.graph.toList

full_name: Finsupp.toAList_keys_toFinset
code: @[simp]
theorem toAList_keys_toFinset [DecidableEq α] (f : α →₀ M) :
    f.toAList.keys.toFinset = f.support 
goal: f.toAList.keys.toFinset = f.support

full_name: Finsupp.mem_toAlist
code: @[simp]
theorem mem_toAlist {f : α →₀ M} {x : α} : x ∈ f.toAList ↔ f x ≠ 0 
goal: x ∈ f.toAList ↔ f x ≠ 0

full_name: AList.lookupFinsupp
code: /-- Converts an association list into a finitely supported function via `AList.lookup`, sending
absent keys to zero. -/
noncomputable def lookupFinsupp (l : AList fun _x : α => M) : α →₀ M 
goal: α →₀ M

full_name: AList.lookupFinsupp_apply
code: @[simp]
theorem lookupFinsupp_apply [DecidableEq α] (l : AList fun _x : α => M) (a : α) :
    l.lookupFinsupp a = (l.lookup a).getD 0 
goal: l.lookupFinsupp a = (AList.lookup a l).getD 0

full_name: AList.lookupFinsupp_support
code: @[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 
goal: l.lookupFinsupp.support = (List.filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset

full_name: AList.lookupFinsupp_eq_iff_of_ne_zero
code: 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 
goal: l.lookupFinsupp a = x ↔ x ∈ AList.lookup a l

full_name: AList.lookupFinsupp_eq_zero_iff
code: theorem lookupFinsupp_eq_zero_iff [DecidableEq α] {l : AList fun _x : α => M} {a : α} :
    l.lookupFinsupp a = 0 ↔ a ∉ l ∨ (0 : M) ∈ l.lookup a 
goal: l.lookupFinsupp a = 0 ↔ a ∉ l ∨ 0 ∈ AList.lookup a l

full_name: AList.empty_lookupFinsupp
code: @[simp]
theorem empty_lookupFinsupp : lookupFinsupp (∅ : AList fun _x : α => M) = 0 
goal: ∅.lookupFinsupp = 0

full_name: AList.insert_lookupFinsupp
code: @[simp]
theorem insert_lookupFinsupp [DecidableEq α] (l : AList fun _x : α => M) (a : α) (m : M) :
    (l.insert a m).lookupFinsupp = l.lookupFinsupp.update a m 
goal: (AList.insert a m l).lookupFinsupp = l.lookupFinsupp.update a m

full_name: AList.singleton_lookupFinsupp
code: @[simp]
theorem singleton_lookupFinsupp (a : α) (m : M) :
    (singleton a m).lookupFinsupp = Finsupp.single a m 
goal: (AList.singleton a m).lookupFinsupp = Finsupp.single a m

full_name: Finsupp.toAList_lookupFinsupp
code: @[simp]
theorem _root_.Finsupp.toAList_lookupFinsupp (f : α →₀ M) : f.toAList.lookupFinsupp = f 
goal: f.toAList.lookupFinsupp = f

full_name: AList.lookupFinsupp_surjective
code: theorem lookupFinsupp_surjective : Function.Surjective (@lookupFinsupp α M _) 
goal: Function.Surjective AList.lookupFinsupp
File: Mathlib/Data/Finsupp/Notation.lean

full_name: Finsupp.fun₀.matchAlts
code: @[nolint docBlame] -- we do not want any doc hover on this notation.
def fun₀.matchAlts : Parser 
goal: Lean.Parser.Parser

full_name: Finsupp.fun₀
code: /-- `fun₀ | i => a` is notation for `Finsupp.single i a`, and with multiple match arms,
`fun₀ ... | i => a` is notation for `Finsupp.update (fun₀ ...) i a`.

As a result, if multiple match arms coincide, the last one takes precedence. -/
@[term_parser]
def fun₀ 
goal: Lean.Parser.Parser

full_name: Finsupp.stxSingle₀
code: /-- Implementation detail for `fun₀`, used by both `Finsupp` and `DFinsupp` -/
local syntax:lead (name := stxSingle₀) "single₀" term:arg term:arg : term
goal: Lean.ParserDescr

full_name: Finsupp.stxUpdate₀
code: /-- Implementation detail for `fun₀`, used by both `Finsupp` and `DFinsupp` -/
local syntax:lead (name := stxUpdate₀) "update₀" term:arg term:arg term:arg : term
goal: Lean.ParserDescr

full_name: Finsupp.elabSingle₀
code: /-- `Finsupp` elaborator for `single₀`. -/
@[term_elab stxSingle₀]
def elabSingle₀ : Elab.Term.TermElab
  
goal: Lean.Elab.Term.TermElab

full_name: Finsupp.elabUpdate₀
code: /-- `Finsupp` elaborator for `update₀`. -/
@[term_elab stxUpdate₀]
def elabUpdate₀ : Elab.Term.TermElab
  
goal: Lean.Elab.Term.TermElab

full_name: Finsupp._aux_Mathlib_Data_Finsupp_Notation___macroRules_Finsupp_fun₀_1
code: macro_rules
  | `(term| fun₀ $x:matchAlt*) => do
    let mut stx : Term ← `(0)
    let mut fst : Bool := true
    for xi in x do
      for xii in (← Elab.Term.expandMatchAlt xi) do
        match xii with
        | `(matchAltExpr| | $pat => $val) =>
          if fst then
            stx ← `(single₀ $pat $val)
          else
            stx ← `(update₀ $stx $pat $val)
          fst := false
        | _ => Macro.throwUnsupported
    pure stx
goal: Lean.Macro

full_name: Finsupp.singleUnexpander
code: /-- Unexpander for the `fun₀ | i => x` notation. -/
@[app_unexpander Finsupp.single]
def singleUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: Finsupp.updateUnexpander
code: /-- Unexpander for the `fun₀ | i => x` notation. -/
@[app_unexpander Finsupp.update]
def updateUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: Finsupp.instRepr
code: /-- Display `Finsupp` using `fun₀` notation. -/
unsafe instance instRepr {α β} [Repr α] [Repr β] [Zero β] : Repr (α →₀ β) 
goal: Repr (α →₀ β)
File: Mathlib/Data/Finsupp/BigOperators.lean

full_name: List.support_sum_subset
code: theorem List.support_sum_subset [AddMonoid M] (l : List (ι →₀ M)) :
    l.sum.support ⊆ l.foldr (Finsupp.support · ⊔ ·) ∅ 
goal: l.sum.support ⊆ List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l

full_name: Multiset.support_sum_subset
code: theorem Multiset.support_sum_subset [AddCommMonoid M] (s : Multiset (ι →₀ M)) :
    s.sum.support ⊆ (s.map Finsupp.support).sup 
goal: s.sum.support ⊆ (Multiset.map Finsupp.support s).sup

full_name: Finset.support_sum_subset
code: theorem Finset.support_sum_subset [AddCommMonoid M] (s : Finset (ι →₀ M)) :
    (s.sum id).support ⊆ Finset.sup s Finsupp.support 
goal: (s.sum id).support ⊆ s.sup Finsupp.support

full_name: List.mem_foldr_sup_support_iff
code: theorem List.mem_foldr_sup_support_iff [Zero M] {l : List (ι →₀ M)} {x : ι} :
    x ∈ l.foldr (Finsupp.support · ⊔ ·) ∅ ↔ ∃ f ∈ l, x ∈ f.support 
goal: x ∈ List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l ↔ ∃ f ∈ l, x ∈ f.support

full_name: Multiset.mem_sup_map_support_iff
code: theorem Multiset.mem_sup_map_support_iff [Zero M] {s : Multiset (ι →₀ M)} {x : ι} :
    x ∈ (s.map Finsupp.support).sup ↔ ∃ f ∈ s, x ∈ f.support 
goal: x ∈ (Multiset.map Finsupp.support s).sup ↔ ∃ f ∈ s, x ∈ f.support

full_name: Finset.mem_sup_support_iff
code: theorem Finset.mem_sup_support_iff [Zero M] {s : Finset (ι →₀ M)} {x : ι} :
    x ∈ s.sup Finsupp.support ↔ ∃ f ∈ s, x ∈ f.support 
goal: x ∈ s.sup Finsupp.support ↔ ∃ f ∈ s, x ∈ f.support

full_name: List.support_sum_eq
code: 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 · ⊔ ·) ∅ 
goal: l.sum.support = List.foldr (fun x x_1 => x.support ⊔ x_1) ∅ l

full_name: Multiset.support_sum_eq
code: 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 
goal: s.sum.support = (Multiset.map Finsupp.support s).sup

full_name: Finset.support_sum_eq
code: 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 
goal: (s.sum id).support = s.sup Finsupp.support
File: Mathlib/Data/Finsupp/WellFounded.lean

full_name: Finsupp.Lex.acc
code: /-- Transferred from `DFinsupp.Lex.acc`. See the top of that file for an explanation for the
  appearance of the relation `rᶜ ⊓ (≠)`. -/
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 
goal: Acc (Finsupp.Lex r s) x

full_name: Finsupp.Lex.wellFounded
code: theorem Lex.wellFounded (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s)
    (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) 
goal: WellFounded (Finsupp.Lex r s)

full_name: Finsupp.Lex.wellFounded'
code: theorem Lex.wellFounded' (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s)
    [IsTrichotomous α r] (hr : WellFounded (Function.swap r)) : WellFounded (Finsupp.Lex r s) 
goal: WellFounded (Finsupp.Lex r s)

full_name: Finsupp.Lex.wellFoundedLT
code: instance Lex.wellFoundedLT {α N} [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
    [CanonicallyOrderedAddCommMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) 
goal: WellFoundedLT (Lex (α →₀ N))

full_name: Finsupp.Lex.wellFounded_of_finite
code: theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α]
    (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) 
goal: WellFounded (Finsupp.Lex r s)

full_name: Finsupp.Lex.wellFoundedLT_of_finite
code: theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [LT N]
    [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) 
goal: WellFoundedLT (Lex (α →₀ N))

full_name: Finsupp.wellFoundedLT
code: protected theorem wellFoundedLT [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
    WellFoundedLT (α →₀ N) 
goal: WellFoundedLT (α →₀ N)

full_name: Finsupp.wellFoundedLT'
code: instance wellFoundedLT' {N} [CanonicallyOrderedAddCommMonoid N] [WellFoundedLT N] :
    WellFoundedLT (α →₀ N) 
goal: WellFoundedLT (α →₀ N)

full_name: Finsupp.wellFoundedLT_of_finite
code: instance wellFoundedLT_of_finite [Finite α] [Preorder N] [WellFoundedLT N] :
    WellFoundedLT (α →₀ N) 
goal: WellFoundedLT (α →₀ N)
File: Mathlib/Data/Finsupp/Weight.lean

full_name: Finsupp.weight
code: /-- The `weight` of the finitely supported function `f : σ →₀ ℕ`
with respect to `w : σ → M` is the sum `∑(f i)•(w i)`. -/
noncomputable def weight : (σ →₀ ℕ) →+ M 
goal: (σ →₀ ℕ) →+ M

full_name: Finsupp.weight_apply
code: theorem weight_apply (f : σ →₀ ℕ) :
    weight w f = Finsupp.sum f (fun i c => c • w i) 
goal: (Finsupp.weight w) f = f.sum fun i c => c • w i

full_name: Finsupp.NonTorsionWeight
code: /-- A weight function is nontorsion if its values are not torsion. -/
class NonTorsionWeight (w : σ → M) : Prop where
  eq_zero_of_smul_eq_zero {n : ℕ} {s : σ} (h : n • w s = 0)  : n = 0
goal: Prop

full_name: Finsupp.NonTorsionWeight.eq_zero_of_smul_eq_zero
code: /-- A weight function is nontorsion if its values are not torsion. -/
class NonTorsionWeight (w : σ → M) : Prop where
  eq_zero_of_smul_eq_zero {n : ℕ} {s : σ} (h : n • w s = 0)  : n = 0
goal: n = 0

full_name: Finsupp.nonTorsionWeight_of
code: /-- Without zero divisors, nonzero weight is a `NonTorsionWeight` -/
theorem nonTorsionWeight_of [NoZeroSMulDivisors ℕ M] (hw : ∀ i : σ, w i ≠ 0) :
    NonTorsionWeight w 
goal: Finsupp.NonTorsionWeight w

full_name: Finsupp.NonTorsionWeight.ne_zero
code: theorem NonTorsionWeight.ne_zero [NonTorsionWeight w] (s : σ) :
    w s ≠ 0 
goal: w s ≠ 0

full_name: Finsupp.le_weight
code: theorem le_weight (w : σ → ℕ) {s : σ} (hs : w s ≠ 0) (f : σ →₀ ℕ) :
    f s ≤ weight w f 
goal: f s ≤ (Finsupp.weight w) f

full_name: Finsupp.instSMulPosMonoNat
code: instance : SMulPosMono ℕ M 
goal: SMulPosMono ℕ M

full_name: Finsupp.le_weight_of_ne_zero
code: theorem le_weight_of_ne_zero (hw : ∀ s, 0 ≤ w s) {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0) :
    w s ≤ weight w f 
goal: w s ≤ (Finsupp.weight w) f

full_name: Finsupp.le_weight_of_ne_zero'
code: theorem le_weight_of_ne_zero' {s : σ} {f : σ →₀ ℕ} (hs : f s ≠ 0) :
    w s ≤ weight w f 
goal: w s ≤ (Finsupp.weight w) f

full_name: Finsupp.weight_eq_zero_iff_eq_zero
code: /-- If `M` is a `CanonicallyOrderedAddCommMonoid`, then `weight f` is zero iff `f=0. -/
theorem weight_eq_zero_iff_eq_zero
    (w : σ → M) [NonTorsionWeight w] {f : σ →₀ ℕ} :
    weight w f = 0 ↔ f = 0 
goal: (Finsupp.weight w) f = 0 ↔ f = 0

full_name: Finsupp.degree
code: /-- The degree of a finsupp function. -/
def degree (d : σ →₀ ℕ) 
goal: ℕ

full_name: Finsupp.degree_eq_zero_iff
code: lemma degree_eq_zero_iff (d : σ →₀ ℕ) : degree d = 0 ↔ d = 0 
goal: d.degree = 0 ↔ d = 0

full_name: Finsupp.degree_zero
code: @[simp]
theorem degree_zero : degree (0 : σ →₀ ℕ) = 0 
goal: Finsupp.degree 0 = 0

full_name: Finsupp.degree_eq_weight_one
code: theorem degree_eq_weight_one :
    degree (σ := σ) = weight 1 
goal: Finsupp.degree = ⇑(Finsupp.weight 1)

full_name: Finsupp.le_degree
code: theorem le_degree (s : σ) (f : σ →₀ ℕ) : f s ≤ degree f  
goal: f s ≤ f.degree
File: Mathlib/Data/Finsupp/Encodable.lean

full_name: instEncodableFinsuppOfDecidableNeOfNat
code: instance {α β : Type*} [Encodable α] [Encodable β] [Zero β] [∀ x : β, Decidable (x ≠ 0)] :
    Encodable (α →₀ β) 
goal: Encodable (α →₀ β)

full_name: instCountableFinsupp
code: instance {α β : Type*} [Countable α] [Countable β] [Zero β] : Countable (α →₀ β) 
goal: Countable (α →₀ β)
File: Mathlib/Data/Finsupp/Indicator.lean

full_name: Finsupp.indicator
code: /-- Create an element of `ι →₀ α` from a finset `s` and a function `f` defined on this finset. -/
def indicator (s : Finset ι) (f : ∀ i ∈ s, α) : ι →₀ α 
goal: ι →₀ α

full_name: Finsupp.indicator_of_mem
code: theorem indicator_of_mem (hi : i ∈ s) (f : ∀ i ∈ s, α) : indicator s f i = f i hi 
goal: (Finsupp.indicator s f) i = f i hi

full_name: Finsupp.indicator_of_not_mem
code: theorem indicator_of_not_mem (hi : i ∉ s) (f : ∀ i ∈ s, α) : indicator s f i = 0 
goal: (Finsupp.indicator s f) i = 0

full_name: Finsupp.indicator_apply
code: @[simp]
theorem indicator_apply [DecidableEq ι] : indicator s f i = if hi : i ∈ s then f i hi else 0 
goal: (Finsupp.indicator s f) i = if hi : i ∈ s then f i hi else 0

full_name: Finsupp.indicator_injective
code: theorem indicator_injective : Injective fun f : ∀ i ∈ s, α => indicator s f 
goal: Function.Injective fun f => Finsupp.indicator s f

full_name: Finsupp.support_indicator_subset
code: theorem support_indicator_subset : ((indicator s f).support : Set ι) ⊆ s 
goal: ↑(Finsupp.indicator s f).support ⊆ ↑s

full_name: Finsupp.single_eq_indicator
code: lemma single_eq_indicator (b : α) : single i b = indicator {i} (fun _ _ => b) 
goal: Finsupp.single i b = Finsupp.indicator {i} fun x x => b
File: Mathlib/Data/Pi/Interval.lean

full_name: Pi.instLocallyFiniteOrder
code: instance instLocallyFiniteOrder : LocallyFiniteOrder (∀ i, α i) 
goal: LocallyFiniteOrder ((i : ι) → α i)

full_name: Pi.Icc_eq
code: theorem Icc_eq : Icc a b = piFinset fun i => Icc (a i) (b i) 
goal: Finset.Icc a b = Fintype.piFinset fun i => Finset.Icc (a i) (b i)

full_name: Pi.card_Icc
code: theorem card_Icc : (Icc a b).card = ∏ i, (Icc (a i) (b i)).card 
goal: (Finset.Icc a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card

full_name: Pi.card_Ico
code: theorem card_Ico : (Ico a b).card = (∏ i, (Icc (a i) (b i)).card) - 1 
goal: (Finset.Ico a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 1

full_name: Pi.card_Ioc
code: theorem card_Ioc : (Ioc a b).card = (∏ i, (Icc (a i) (b i)).card) - 1 
goal: (Finset.Ioc a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 1

full_name: Pi.card_Ioo
code: theorem card_Ioo : (Ioo a b).card = (∏ i, (Icc (a i) (b i)).card) - 2 
goal: (Finset.Ioo a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 2

full_name: Pi.instLocallyFiniteOrderBot
code: instance instLocallyFiniteOrderBot : LocallyFiniteOrderBot (∀ i, α i) 
goal: LocallyFiniteOrderBot ((i : ι) → α i)

full_name: Pi.card_Iic
code: theorem card_Iic : (Iic b).card = ∏ i, (Iic (b i)).card 
goal: (Finset.Iic b).card = ∏ i : ι, (Finset.Iic (b i)).card

full_name: Pi.card_Iio
code: theorem card_Iio : (Iio b).card = (∏ i, (Iic (b i)).card) - 1 
goal: (Finset.Iio b).card = ∏ i : ι, (Finset.Iic (b i)).card - 1

full_name: Pi.instLocallyFiniteOrderTop
code: instance instLocallyFiniteOrderTop : LocallyFiniteOrderTop (∀ i, α i) 
goal: LocallyFiniteOrderTop ((i : ι) → α i)

full_name: Pi.card_Ici
code: theorem card_Ici : (Ici a).card = ∏ i, (Ici (a i)).card 
goal: (Finset.Ici a).card = ∏ i : ι, (Finset.Ici (a i)).card

full_name: Pi.card_Ioi
code: theorem card_Ioi : (Ioi a).card = (∏ i, (Ici (a i)).card) - 1 
goal: (Finset.Ioi a).card = ∏ i : ι, (Finset.Ici (a i)).card - 1

full_name: Pi.uIcc_eq
code: theorem uIcc_eq : uIcc a b = piFinset fun i => uIcc (a i) (b i) 
goal: Finset.uIcc a b = Fintype.piFinset fun i => Finset.uIcc (a i) (b i)

full_name: Pi.card_uIcc
code: theorem card_uIcc : (uIcc a b).card = ∏ i, (uIcc (a i) (b i)).card 
goal: (Finset.uIcc a b).card = ∏ i : ι, (Finset.uIcc (a i) (b i)).card
File: Mathlib/Data/Finsupp/Pointwise.lean

full_name: Finsupp.instMul
code: /-- The product of `f g : α →₀ β` is the finitely supported function
  whose value at `a` is `f a * g a`. -/
instance : Mul (α →₀ β) 
goal: Mul (α →₀ β)

full_name: Finsupp.coe_mul
code: theorem coe_mul (g₁ g₂ : α →₀ β) : ⇑(g₁ * g₂) = g₁ * g₂ 
goal: ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂

full_name: Finsupp.mul_apply
code: @[simp]
theorem mul_apply {g₁ g₂ : α →₀ β} {a : α} : (g₁ * g₂) a = g₁ a * g₂ a 
goal: (g₁ * g₂) a = g₁ a * g₂ a

full_name: Finsupp.single_mul
code: @[simp]
theorem single_mul (a : α) (b₁ b₂ : β) : single a (b₁ * b₂) = single a b₁ * single a b₂ 
goal: Finsupp.single a (b₁ * b₂) = Finsupp.single a b₁ * Finsupp.single a b₂

full_name: Finsupp.support_mul
code: theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support 
goal: (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support

full_name: Finsupp.instMulZeroClass
code: instance : MulZeroClass (α →₀ β) 
goal: MulZeroClass (α →₀ β)

full_name: Finsupp.instSemigroupWithZero
code: instance [SemigroupWithZero β] : SemigroupWithZero (α →₀ β) 
goal: SemigroupWithZero (α →₀ β)

full_name: Finsupp.instNonUnitalNonAssocSemiring
code: instance [NonUnitalNonAssocSemiring β] : NonUnitalNonAssocSemiring (α →₀ β) 
goal: NonUnitalNonAssocSemiring (α →₀ β)

full_name: Finsupp.instNonUnitalSemiring
code: instance [NonUnitalSemiring β] : NonUnitalSemiring (α →₀ β) 
goal: NonUnitalSemiring (α →₀ β)

full_name: Finsupp.instNonUnitalCommSemiring
code: instance [NonUnitalCommSemiring β] : NonUnitalCommSemiring (α →₀ β) 
goal: NonUnitalCommSemiring (α →₀ β)

full_name: Finsupp.instNonUnitalNonAssocRing
code: instance [NonUnitalNonAssocRing β] : NonUnitalNonAssocRing (α →₀ β) 
goal: NonUnitalNonAssocRing (α →₀ β)

full_name: Finsupp.instNonUnitalRing
code: instance [NonUnitalRing β] : NonUnitalRing (α →₀ β) 
goal: NonUnitalRing (α →₀ β)

full_name: Finsupp.instNonUnitalCommRing
code: instance [NonUnitalCommRing β] : NonUnitalCommRing (α →₀ β) 
goal: NonUnitalCommRing (α →₀ β)

full_name: Finsupp.pointwiseScalar
code: instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) 
goal: SMul (α → β) (α →₀ β)

full_name: Finsupp.coe_pointwise_smul
code: @[simp]
theorem coe_pointwise_smul [Semiring β] (f : α → β) (g : α →₀ β) : ⇑(f • g) = f • ⇑g 
goal: ⇑(f • g) = f • ⇑g

full_name: Finsupp.pointwiseModule
code: /-- The pointwise multiplicative action of functions on finitely supported functions -/
instance pointwiseModule [Semiring β] : Module (α → β) (α →₀ β) 
goal: Module (α → β) (α →₀ β)
File: Mathlib/Data/Rat/Cast/Lemmas.lean

full_name: Rat.cast_inv_nat
code: @[simp]
theorem cast_inv_nat (n : ℕ) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
goal: ↑(↑n)⁻¹ = (↑n)⁻¹

full_name: Rat.cast_inv_int
code: @[simp]
theorem cast_inv_int (n : ℤ) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
goal: ↑(↑n)⁻¹ = (↑n)⁻¹

full_name: Rat.cast_nnratCast
code: @[simp, norm_cast]
theorem cast_nnratCast {K} [DivisionRing K] (q : ℚ≥0) :
    ((q : ℚ) : K) = (q : K) 
goal: ↑↑q = ↑q

full_name: Rat.cast_ofScientific
code: /-- Casting a scientific literal via `ℚ` is the same as casting directly. -/
@[simp, norm_cast]
theorem cast_ofScientific {K} [DivisionRing K] (m : ℕ) (s : Bool) (e : ℕ) :
    (OfScientific.ofScientific m s e : ℚ) = (OfScientific.ofScientific m s e : K) 
goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e

full_name: NNRat.cast_pow
code: @[simp, norm_cast]
theorem cast_pow {K} [DivisionSemiring K] (q : ℚ≥0) (n : ℕ) :
    NNRat.cast (q ^ n) = (NNRat.cast q : K) ^ n 
goal: ↑(q ^ n) = ↑q ^ n

full_name: NNRat.cast_zpow_of_ne_zero
code: theorem cast_zpow_of_ne_zero {K} [DivisionSemiring K] (q : ℚ≥0) (z : ℤ) (hq : (q.num : K) ≠ 0) :
    NNRat.cast (q ^ z) = (NNRat.cast q : K) ^ z 
goal: ↑(q ^ z) = ↑q ^ z

full_name: NNRat.Nonneg.coe_ofScientific
code: theorem Nonneg.coe_ofScientific {K} [LinearOrderedField K] (m : ℕ) (s : Bool) (e : ℕ) :
    (ofScientific m s e : {x : K // 0 ≤ x}).val = ofScientific m s e 
goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e
File: Mathlib/Data/Rat/BigOperators.lean

full_name: Rat.cast_list_sum
code: @[simp, norm_cast]
theorem cast_list_sum (s : List ℚ) : (↑s.sum : α) = (s.map (↑)).sum 
goal: ↑s.sum = (List.map Rat.cast s).sum

full_name: Rat.cast_multiset_sum
code: @[simp, norm_cast]
theorem cast_multiset_sum (s : Multiset ℚ) : (↑s.sum : α) = (s.map (↑)).sum 
goal: ↑s.sum = (Multiset.map Rat.cast s).sum

full_name: Rat.cast_sum
code: @[simp, norm_cast]
theorem cast_sum (s : Finset ι) (f : ι → ℚ) : ∑ i ∈ s, f i = ∑ i ∈ s, (f i : α) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: Rat.cast_list_prod
code: @[simp, norm_cast]
theorem cast_list_prod (s : List ℚ) : (↑s.prod : α) = (s.map (↑)).prod 
goal: ↑s.prod = (List.map Rat.cast s).prod

full_name: Rat.cast_multiset_prod
code: @[simp, norm_cast]
theorem cast_multiset_prod (s : Multiset ℚ) : (↑s.prod : α) = (s.map (↑)).prod 
goal: ↑s.prod = (Multiset.map Rat.cast s).prod

full_name: Rat.cast_prod
code: @[simp, norm_cast]
theorem cast_prod (s : Finset ι) (f : ι → ℚ) : ∏ i ∈ s, f i = ∏ i ∈ s, (f i : α) 
goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)