ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Finset/NatDivisors.lean

full_name: Nat.divisors_mul
code: /-- The divisors of a product of natural numbers are the pointwise product of the divisors of the
factors. -/
lemma Nat.divisors_mul (m n : ℕ) : divisors (m * n) = divisors m * divisors n 
goal: (m * n).divisors = m.divisors * n.divisors

full_name: Nat.divisorsHom
code: /-- `Nat.divisors` as a `MonoidHom`. -/
@[simps]
def Nat.divisorsHom : ℕ →* Finset ℕ 
goal: ℕ →* Finset ℕ

full_name: Nat.divisorsHom_apply
code: /-- `Nat.divisors` as a `MonoidHom`. -/
@[simps]
def Nat.divisorsHom : ℕ →* Finset ℕ 
goal: Nat.divisorsHom n = n.divisors

full_name: Nat.Prime.divisors_sq
code: lemma Nat.Prime.divisors_sq {p : ℕ} (hp : p.Prime) : (p ^ 2).divisors = {p ^ 2, p, 1} 
goal: (p ^ 2).divisors = {p ^ 2, p, 1}

full_name: List.nat_divisors_prod
code: lemma List.nat_divisors_prod (l : List ℕ) : divisors l.prod = (l.map divisors).prod 
goal: l.prod.divisors = (List.map Nat.divisors l).prod

full_name: Multiset.nat_divisors_prod
code: lemma Multiset.nat_divisors_prod (s : Multiset ℕ) : divisors s.prod = (s.map divisors).prod 
goal: s.prod.divisors = (Multiset.map Nat.divisors s).prod

full_name: Finset.nat_divisors_prod
code: lemma Finset.nat_divisors_prod {ι : Type*} (s : Finset ι) (f : ι → ℕ) :
    divisors (∏ i ∈ s, f i) = ∏ i ∈ s, divisors (f i) 
goal: (∏ i ∈ s, f i).divisors = ∏ i ∈ s, (f i).divisors
File: Mathlib/Data/Finset/Order.lean

full_name: Directed.finset_le
code: theorem Directed.finset_le {r : α → α → Prop} [IsTrans α r] {ι} [hι : Nonempty ι] {f : ι → α}
    (D : Directed r f) (s : Finset ι) : ∃ z, ∀ i ∈ s, r (f i) (f z) 
goal: ∃ z, ∀ i ∈ s, r (f i) (f z)

full_name: Finset.exists_le
code: theorem Finset.exists_le [Nonempty α] [Preorder α] [IsDirected α (· ≤ ·)] (s : Finset α) :
    ∃ M, ∀ i ∈ s, i ≤ M 
goal: ∃ M, ∀ i ∈ s, i ≤ M
File: Mathlib/Data/Finset/Finsupp.lean

full_name: Finset.finsupp
code: /-- Finitely supported product of finsets. -/
protected def finsupp (s : Finset ι) (t : ι → Finset α) : Finset (ι →₀ α) 
goal: Finset (ι →₀ α)

full_name: Finset.mem_finsupp_iff
code: theorem mem_finsupp_iff {t : ι → Finset α} :
    f ∈ s.finsupp t ↔ f.support ⊆ s ∧ ∀ i ∈ s, f i ∈ t i 
goal: f ∈ s.finsupp t ↔ f.support ⊆ s ∧ ∀ i ∈ s, f i ∈ t i

full_name: Finset.mem_finsupp_iff_of_support_subset
code: /-- When `t` is supported on `s`, `f ∈ s.finsupp t` precisely means that `f` is pointwise in `t`. -/
@[simp]
theorem mem_finsupp_iff_of_support_subset {t : ι →₀ Finset α} (ht : t.support ⊆ s) :
    f ∈ s.finsupp t ↔ ∀ i, f i ∈ t i 
goal: f ∈ s.finsupp ⇑t ↔ ∀ (i : ι), f i ∈ t i

full_name: Finset.card_finsupp
code: @[simp]
theorem card_finsupp (s : Finset ι) (t : ι → Finset α) :
    (s.finsupp t).card = ∏ i ∈ s, (t i).card 
goal: (s.finsupp t).card = ∏ i ∈ s, (t i).card

full_name: Finsupp.pi
code: /-- Given a finitely supported function `f : ι →₀ Finset α`, one can define the finset
`f.pi` of all finitely supported functions whose value at `i` is in `f i` for all `i`. -/
def pi (f : ι →₀ Finset α) : Finset (ι →₀ α) 
goal: Finset (ι →₀ α)

full_name: Finsupp.mem_pi
code: @[simp]
theorem mem_pi {f : ι →₀ Finset α} {g : ι →₀ α} : g ∈ f.pi ↔ ∀ i, g i ∈ f i 
goal: g ∈ f.pi ↔ ∀ (i : ι), g i ∈ f i

full_name: Finsupp.card_pi
code: @[simp]
theorem card_pi (f : ι →₀ Finset α) : f.pi.card = f.prod fun i => (f i).card 
goal: f.pi.card = f.prod fun i => ↑(f i).card
File: Mathlib/Data/Finset/PiInduction.lean

full_name: Finset.induction_on_pi_of_choice
code: /-- General theorem for `Finset.induction_on_pi`-style induction principles. -/
theorem induction_on_pi_of_choice (r : ∀ i, α i → Finset (α i) → Prop)
    (H_ex : ∀ (i) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x))
    {p : (∀ i, Finset (α i)) → Prop} (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        r i x (g i) → p g → p (update g i (insert x (g i)))) :
    p f 
goal: p f

full_name: Finset.induction_on_pi
code: /-- Given a predicate on functions `∀ i, Finset (α i)` defined on a finite type, it is true on all
maps provided that it is true on `fun _ ↦ ∅` and for any function `g : ∀ i, Finset (α i)`, an index
`i : ι`, and `x ∉ g i`, `p g` implies `p (update g i (insert x (g i)))`.

See also `Finset.induction_on_pi_max` and `Finset.induction_on_pi_min` for specialized versions
that require `∀ i, LinearOrder (α i)`.  -/
theorem induction_on_pi {p : (∀ i, Finset (α i)) → Prop} (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step : ∀ (g : ∀ i, Finset (α i)) (i : ι), ∀ x ∉ g i, p g → p (update g i (insert x (g i)))) :
    p f 
goal: p f

full_name: Finset.induction_on_pi_max
code: /-- Given a predicate on functions `∀ i, Finset (α i)` defined on a finite type, it is true on all
maps provided that it is true on `fun _ ↦ ∅` and for any function `g : ∀ i, Finset (α i)`, an index
`i : ι`, and an element`x : α i` that is strictly greater than all elements of `g i`, `p g` implies
`p (update g i (insert x (g i)))`.

This lemma requires `LinearOrder` instances on all `α i`. See also `Finset.induction_on_pi` for a
version that `x ∉ g i` instead of ` does not need `∀ i, LinearOrder (α i)`. -/
theorem induction_on_pi_max [∀ i, LinearOrder (α i)] {p : (∀ i, Finset (α i)) → Prop}
    (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        (∀ y ∈ g i, y < x) → p g → p (update g i (insert x (g i)))) :
    p f 
goal: p f

full_name: Finset.induction_on_pi_min
code: /-- Given a predicate on functions `∀ i, Finset (α i)` defined on a finite type, it is true on all
maps provided that it is true on `fun _ ↦ ∅` and for any function `g : ∀ i, Finset (α i)`, an index
`i : ι`, and an element`x : α i` that is strictly less than all elements of `g i`, `p g` implies
`p (update g i (insert x (g i)))`.

This lemma requires `LinearOrder` instances on all `α i`. See also `Finset.induction_on_pi` for a
version that `x ∉ g i` instead of ` does not need `∀ i, LinearOrder (α i)`. -/
theorem induction_on_pi_min [∀ i, LinearOrder (α i)] {p : (∀ i, Finset (α i)) → Prop}
    (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        (∀ y ∈ g i, x < y) → p g → p (update g i (insert x (g i)))) :
    p f 
goal: p f
File: Mathlib/Data/Finset/Attr.lean

full_name: initFn._@.Mathlib.Data.Finset.Attr._hyg.5
code: declare_aesop_rule_sets [finsetNonempty] (default := true)
goal: IO Unit
File: Mathlib/Data/Finset/Update.lean

full_name: Function.updateFinset
code: /-- `updateFinset x s y` is the vector `x` with the coordinates in `s` changed to the values of `y`.
-/
def updateFinset (x : ∀ i, π i) (s : Finset ι) (y : ∀ i : ↥s, π i) (i : ι) : π i 
goal: π i

full_name: Function.updateFinset_def
code: theorem updateFinset_def {s : Finset ι} {y} :
    updateFinset x s y = fun i ↦ if hi : i ∈ s then y ⟨i, hi⟩ else x i 
goal: Function.updateFinset x s y = fun i => if hi : i ∈ s then y ⟨i, hi⟩ else x i

full_name: Function.updateFinset_empty
code: @[simp] theorem updateFinset_empty {y} : updateFinset x ∅ y = x 
goal: Function.updateFinset x ∅ y = x

full_name: Function.updateFinset_singleton
code: theorem updateFinset_singleton {i y} :
    updateFinset x {i} y = Function.update x i (y ⟨i, mem_singleton_self i⟩) 
goal: Function.updateFinset x {i} y = Function.update x i (y ⟨i, ⋯⟩)

full_name: Function.update_eq_updateFinset
code: theorem update_eq_updateFinset {i y} :
    Function.update x i y = updateFinset x {i} (uniqueElim y) 
goal: Function.update x i y = Function.updateFinset x {i} (uniqueElim y)

full_name: Function.updateFinset_updateFinset
code: theorem updateFinset_updateFinset {s t : Finset ι} (hst : Disjoint s t)
    {y : ∀ i : ↥s, π i} {z : ∀ i : ↥t, π i} :
    updateFinset (updateFinset x s y) t z =
    updateFinset x (s ∪ t) (Equiv.piFinsetUnion π hst ⟨y, z⟩) 
goal: Function.updateFinset (Function.updateFinset x s y) t z =
  Function.updateFinset x (s ∪ t) ((Equiv.piFinsetUnion π hst) (y, z))
File: Mathlib/Data/Finset/PImage.lean

full_name: Part.toFinset
code: /-- Convert an `o : Part α` with decidable `Part.Dom o` to `Finset α`. -/
def toFinset (o : Part α) [Decidable o.Dom] : Finset α 
goal: Finset α

full_name: Part.mem_toFinset
code: @[simp]
theorem mem_toFinset {o : Part α} [Decidable o.Dom] {x : α} : x ∈ o.toFinset ↔ x ∈ o 
goal: x ∈ o.toFinset ↔ x ∈ o

full_name: Part.toFinset_none
code: @[simp]
theorem toFinset_none [Decidable (none : Part α).Dom] : none.toFinset = (∅ : Finset α) 
goal: Part.none.toFinset = ∅

full_name: Part.toFinset_some
code: @[simp]
theorem toFinset_some {a : α} [Decidable (some a).Dom] : (some a).toFinset = {a} 
goal: (Part.some a).toFinset = {a}

full_name: Part.coe_toFinset
code: @[simp]
theorem coe_toFinset (o : Part α) [Decidable o.Dom] : (o.toFinset : Set α) = { x | x ∈ o } 
goal: ↑o.toFinset = {x | x ∈ o}

full_name: Finset.pimage
code: /-- Image of `s : Finset α` under a partially defined function `f : α →. β`. -/
def pimage (f : α →. β) [∀ x, Decidable (f x).Dom] (s : Finset α) : Finset β 
goal: Finset β

full_name: Finset.mem_pimage
code: @[simp]
theorem mem_pimage : b ∈ s.pimage f ↔ ∃ a ∈ s, b ∈ f a 
goal: b ∈ Finset.pimage f s ↔ ∃ a ∈ s, b ∈ f a

full_name: Finset.coe_pimage
code: @[simp, norm_cast]
theorem coe_pimage : (s.pimage f : Set β) = f.image s 
goal: ↑(Finset.pimage f s) = f.image ↑s

full_name: Finset.pimage_some
code: @[simp]
theorem pimage_some (s : Finset α) (f : α → β) [∀ x, Decidable (Part.some <| f x).Dom] :
    (s.pimage fun x => Part.some (f x)) = s.image f 
goal: Finset.pimage (fun x => Part.some (f x)) s = Finset.image f s

full_name: Finset.pimage_congr
code: theorem pimage_congr (h₁ : s = t) (h₂ : ∀ x ∈ t, f x = g x) : s.pimage f = t.pimage g 
goal: Finset.pimage f s = Finset.pimage g t

full_name: Finset.pimage_eq_image_filter
code: /-- Rewrite `s.pimage f` in terms of `Finset.filter`, `Finset.attach`, and `Finset.image`. -/
theorem pimage_eq_image_filter : s.pimage f =
    (filter (fun x => (f x).Dom) s).attach.image
      fun x : { x // x ∈ filter (fun x => (f x).Dom) s } =>
        (f x).get (mem_filter.mp x.coe_prop).2 
goal: Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) (Finset.filter (fun x => (f x).Dom) s).attach

full_name: Finset.pimage_union
code: theorem pimage_union [DecidableEq α] : (s ∪ t).pimage f = s.pimage f ∪ t.pimage f 
goal: Finset.pimage f (s ∪ t) = Finset.pimage f s ∪ Finset.pimage f t

full_name: Finset.pimage_empty
code: @[simp]
theorem pimage_empty : pimage f ∅ = ∅ 
goal: Finset.pimage f ∅ = ∅

full_name: Finset.pimage_subset
code: theorem pimage_subset {t : Finset β} : s.pimage f ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t 
goal: Finset.pimage f s ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t

full_name: Finset.pimage_mono
code: @[mono]
theorem pimage_mono (h : s ⊆ t) : s.pimage f ⊆ t.pimage f 
goal: Finset.pimage f s ⊆ Finset.pimage f t

full_name: Finset.pimage_inter
code: theorem pimage_inter [DecidableEq α] : (s ∩ t).pimage f ⊆ s.pimage f ∩ t.pimage f 
goal: Finset.pimage f (s ∩ t) ⊆ Finset.pimage f s ∩ Finset.pimage f t
File: Mathlib/Data/Finset/Pairwise.lean

full_name: instDecidablePairwiseToSetOfDecidableEqOfDecidableRel
code: instance [DecidableEq α] {r : α → α → Prop} [DecidableRel r] {s : Finset α} :
    Decidable ((s : Set α).Pairwise r) 
goal: Decidable ((↑s).Pairwise r)

full_name: Finset.pairwiseDisjoint_range_singleton
code: theorem Finset.pairwiseDisjoint_range_singleton :
    (Set.range (singleton : α → Finset α)).PairwiseDisjoint id 
goal: (Set.range singleton).PairwiseDisjoint id

full_name: Set.PairwiseDisjoint.elim_finset
code: theorem PairwiseDisjoint.elim_finset {s : Set ι} {f : ι → Finset α} (hs : s.PairwiseDisjoint f)
    {i j : ι} (hi : i ∈ s) (hj : j ∈ s) (a : α) (hai : a ∈ f i) (haj : a ∈ f j) : i = j 
goal: i = j

full_name: Set.PairwiseDisjoint.image_finset_of_le
code: theorem PairwiseDisjoint.image_finset_of_le [DecidableEq ι] {s : Finset ι} {f : ι → α}
    (hs : (s : Set ι).PairwiseDisjoint f) {g : ι → ι} (hf : ∀ a, f (g a) ≤ f a) :
    (s.image g : Set ι).PairwiseDisjoint f 
goal: (↑(Finset.image g s)).PairwiseDisjoint f

full_name: Set.PairwiseDisjoint.attach
code: theorem PairwiseDisjoint.attach (hs : (s : Set ι).PairwiseDisjoint f) :
    (s.attach : Set { x // x ∈ s }).PairwiseDisjoint (f ∘ Subtype.val) 
goal: (↑s.attach).PairwiseDisjoint (f ∘ Subtype.val)

full_name: Set.PairwiseDisjoint.biUnion_finset
code: /-- Bind operation for `Set.PairwiseDisjoint`. In a complete lattice, you can use
`Set.PairwiseDisjoint.biUnion`. -/
theorem PairwiseDisjoint.biUnion_finset {s : Set ι'} {g : ι' → Finset ι} {f : ι → α}
    (hs : s.PairwiseDisjoint fun i' : ι' => (g i').sup f)
    (hg : ∀ i ∈ s, (g i : Set ι).PairwiseDisjoint f) : (⋃ i ∈ s, ↑(g i)).PairwiseDisjoint f 
goal: (⋃ i ∈ s, ↑(g i)).PairwiseDisjoint f

full_name: List.pairwise_of_coe_toFinset_pairwise
code: theorem pairwise_of_coe_toFinset_pairwise (hl : (l.toFinset : Set α).Pairwise r) (hn : l.Nodup) :
    l.Pairwise r 
goal: List.Pairwise r l

full_name: List.pairwise_iff_coe_toFinset_pairwise
code: theorem pairwise_iff_coe_toFinset_pairwise (hn : l.Nodup) (hs : Symmetric r) :
    (l.toFinset : Set α).Pairwise r ↔ l.Pairwise r 
goal: (↑l.toFinset).Pairwise r ↔ List.Pairwise r l

full_name: List.pairwise_disjoint_of_coe_toFinset_pairwiseDisjoint
code: theorem pairwise_disjoint_of_coe_toFinset_pairwiseDisjoint {α ι} [SemilatticeInf α] [OrderBot α]
    [DecidableEq ι] {l : List ι} {f : ι → α} (hl : (l.toFinset : Set ι).PairwiseDisjoint f)
    (hn : l.Nodup) : l.Pairwise (_root_.Disjoint on f) 
goal: List.Pairwise (Disjoint on f) l

full_name: List.pairwiseDisjoint_iff_coe_toFinset_pairwise_disjoint
code: theorem pairwiseDisjoint_iff_coe_toFinset_pairwise_disjoint {α ι} [SemilatticeInf α] [OrderBot α]
    [DecidableEq ι] {l : List ι} {f : ι → α} (hn : l.Nodup) :
    (l.toFinset : Set ι).PairwiseDisjoint f ↔ l.Pairwise (_root_.Disjoint on f) 
goal: (↑l.toFinset).PairwiseDisjoint f ↔ List.Pairwise (Disjoint on f) l
File: Mathlib/Data/Prod/PProd.lean

full_name: PProd.mk.eta
code: @[simp]
theorem mk.eta {p : PProd α β} : PProd.mk p.1 p.2 = p 
goal: ⟨p.fst, p.snd⟩ = p

full_name: PProd.forall
code: @[simp]
theorem «forall» {p : PProd α β → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
goal: (∀ (x : PProd α β), p x) ↔ ∀ (a : α) (b : β), p ⟨a, b⟩

full_name: PProd.exists
code: @[simp]
theorem «exists» {p : PProd α β → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩

full_name: PProd.forall'
code: theorem forall' {p : α → β → Prop} : (∀ x : PProd α β, p x.1 x.2) ↔ ∀ a b, p a b 
goal: (∀ (x : PProd α β), p x.fst x.snd) ↔ ∀ (a : α) (b : β), p a b

full_name: PProd.exists'
code: theorem exists' {p : α → β → Prop} : (∃ x : PProd α β, p x.1 x.2) ↔ ∃ a b, p a b 
goal: (∃ x, p x.fst x.snd) ↔ ∃ a b, p a b

full_name: Function.Injective.pprod_map
code: theorem Function.Injective.pprod_map {f : α → β} {g : γ → δ} (hf : Injective f) (hg : Injective g) :
    Injective (fun x ↦ ⟨f x.1, g x.2⟩ : PProd α γ → PProd β δ) 
goal: Function.Injective fun x => ⟨f x.fst, g x.snd⟩
File: Mathlib/Data/Sigma/Interval.lean

full_name: Sigma.instLocallyFiniteOrder
code: instance instLocallyFiniteOrder : LocallyFiniteOrder (Σ i, α i) 
goal: LocallyFiniteOrder ((i : ι) × α i)

full_name: Sigma.card_Icc
code: theorem card_Icc : (Icc a b).card = if h : a.1 = b.1 then (Icc (h.rec a.2) b.2).card else 0 
goal: (Finset.Icc a b).card = if h : a.fst = b.fst then (Finset.Icc (h ▸ a.snd) b.snd).card else 0

full_name: Sigma.card_Ico
code: theorem card_Ico : (Ico a b).card = if h : a.1 = b.1 then (Ico (h.rec a.2) b.2).card else 0 
goal: (Finset.Ico a b).card = if h : a.fst = b.fst then (Finset.Ico (h ▸ a.snd) b.snd).card else 0

full_name: Sigma.card_Ioc
code: theorem card_Ioc : (Ioc a b).card = if h : a.1 = b.1 then (Ioc (h.rec a.2) b.2).card else 0 
goal: (Finset.Ioc a b).card = if h : a.fst = b.fst then (Finset.Ioc (h ▸ a.snd) b.snd).card else 0

full_name: Sigma.card_Ioo
code: theorem card_Ioo : (Ioo a b).card = if h : a.1 = b.1 then (Ioo (h.rec a.2) b.2).card else 0 
goal: (Finset.Ioo a b).card = if h : a.fst = b.fst then (Finset.Ioo (h ▸ a.snd) b.snd).card else 0

full_name: Sigma.Icc_mk_mk
code: @[simp]
theorem Icc_mk_mk : Icc (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Icc a b).map (Embedding.sigmaMk i) 
goal: Finset.Icc ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Icc a b)

full_name: Sigma.Ico_mk_mk
code: @[simp]
theorem Ico_mk_mk : Ico (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ico a b).map (Embedding.sigmaMk i) 
goal: Finset.Ico ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ico a b)

full_name: Sigma.Ioc_mk_mk
code: @[simp]
theorem Ioc_mk_mk : Ioc (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ioc a b).map (Embedding.sigmaMk i) 
goal: Finset.Ioc ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ioc a b)

full_name: Sigma.Ioo_mk_mk
code: @[simp]
theorem Ioo_mk_mk : Ioo (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ioo a b).map (Embedding.sigmaMk i) 
goal: Finset.Ioo ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ioo a b)
File: Mathlib/Data/Matroid/Init.lean

full_name: initFn._@.Mathlib.Data.Matroid.Init._hyg.5
code: declare_aesop_rule_sets [Matroid]
goal: IO Unit
File: Mathlib/Data/Matrix/CharP.lean

full_name: Matrix.charP
code: instance Matrix.charP [DecidableEq n] [Nonempty n] (p : ℕ) [CharP R p] :
    CharP (Matrix n n R) p 
goal: CharP (Matrix n n R) p
File: Mathlib/Data/Matrix/Hadamard.lean

full_name: Matrix.hadamard
code: /-- `Matrix.hadamard` defines the Hadamard product,
    which is the pointwise product of two matrices of the same size. -/
def hadamard [Mul α] (A : Matrix m n α) (B : Matrix m n α) : Matrix m n α 
goal: Matrix m n α

full_name: Matrix.hadamard_apply
code: @[simp]
theorem hadamard_apply [Mul α] (A : Matrix m n α) (B : Matrix m n α) (i j) :
    hadamard A B i j = A i j * B i j 
goal: A.hadamard B i j = A i j * B i j

full_name: Matrix.«_aux_Mathlib_Data_Matrix_Hadamard___macroRules_Matrix_term_⊙__1»
code: scoped infixl:100 " ⊙ " => Matrix.hadamard
goal: Lean.Macro

full_name: Matrix._aux_Mathlib_Data_Matrix_Hadamard___unexpand_Matrix_hadamard_1
code: scoped infixl:100 " ⊙ " => Matrix.hadamard
goal: Lean.PrettyPrinter.Unexpander

full_name: Matrix.hadamard_comm
code: theorem hadamard_comm [CommSemigroup α] : A ⊙ B = B ⊙ A 
goal: A.hadamard B = B.hadamard A

full_name: Matrix.hadamard_assoc
code: theorem hadamard_assoc [Semigroup α] : A ⊙ B ⊙ C = A ⊙ (B ⊙ C) 
goal: (A.hadamard B).hadamard C = A.hadamard (B.hadamard C)

full_name: Matrix.hadamard_add
code: theorem hadamard_add [Distrib α] : A ⊙ (B + C) = A ⊙ B + A ⊙ C 
goal: A.hadamard (B + C) = A.hadamard B + A.hadamard C

full_name: Matrix.add_hadamard
code: theorem add_hadamard [Distrib α] : (B + C) ⊙ A = B ⊙ A + C ⊙ A 
goal: (B + C).hadamard A = B.hadamard A + C.hadamard A

full_name: Matrix.smul_hadamard
code: @[simp]
theorem smul_hadamard [Mul α] [SMul R α] [IsScalarTower R α α] (k : R) : (k • A) ⊙ B = k • A ⊙ B 
goal: (k • A).hadamard B = k • A.hadamard B

full_name: Matrix.hadamard_smul
code: @[simp]
theorem hadamard_smul [Mul α] [SMul R α] [SMulCommClass R α α] (k : R) : A ⊙ (k • B) = k • A ⊙ B 
goal: A.hadamard (k • B) = k • A.hadamard B

full_name: Matrix.hadamard_zero
code: @[simp]
theorem hadamard_zero : A ⊙ (0 : Matrix m n α) = 0 
goal: A.hadamard 0 = 0

full_name: Matrix.zero_hadamard
code: @[simp]
theorem zero_hadamard : (0 : Matrix m n α) ⊙ A = 0 
goal: Matrix.hadamard 0 A = 0

full_name: Matrix.hadamard_one
code: theorem hadamard_one : M ⊙ (1 : Matrix n n α) = diagonal fun i => M i i 
goal: M.hadamard 1 = Matrix.diagonal fun i => M i i

full_name: Matrix.one_hadamard
code: theorem one_hadamard : (1 : Matrix n n α) ⊙ M = diagonal fun i => M i i 
goal: Matrix.hadamard 1 M = Matrix.diagonal fun i => M i i

full_name: Matrix.diagonal_hadamard_diagonal
code: theorem diagonal_hadamard_diagonal (v : n → α) (w : n → α) :
    diagonal v ⊙ diagonal w = diagonal (v * w) 
goal: (Matrix.diagonal v).hadamard (Matrix.diagonal w) = Matrix.diagonal (v * w)

full_name: Matrix.sum_hadamard_eq
code: theorem sum_hadamard_eq : (∑ i : m, ∑ j : n, (A ⊙ B) i j) = trace (A * Bᵀ) 
goal: ∑ i : m, ∑ j : n, A.hadamard B i j = (A * B.transpose).trace

full_name: Matrix.dotProduct_vecMul_hadamard
code: theorem dotProduct_vecMul_hadamard [DecidableEq m] [DecidableEq n] (v : m → α) (w : n → α) :
    dotProduct (v ᵥ* (A ⊙ B)) w = trace (diagonal v * A * (B * diagonal w)ᵀ) 
goal: Matrix.dotProduct (Matrix.vecMul v (A.hadamard B)) w = (Matrix.diagonal v * A * (B * Matrix.diagonal w).transpose).trace
File: Mathlib/Data/Matrix/DualNumber.lean

full_name: Matrix.dualNumberEquiv
code: /-- Matrices over dual numbers and dual numbers over matrices are isomorphic. -/
@[simps]
def Matrix.dualNumberEquiv : Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R) 
goal: Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R)

full_name: Matrix.dualNumberEquiv_symm_apply
code: /-- Matrices over dual numbers and dual numbers over matrices are isomorphic. -/
@[simps]
def Matrix.dualNumberEquiv : Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R) 
goal: Matrix.dualNumberEquiv.symm d = Matrix.of fun i j => (TrivSqZeroExt.fst d i j, TrivSqZeroExt.snd d i j)

full_name: Matrix.dualNumberEquiv_apply
code: /-- Matrices over dual numbers and dual numbers over matrices are isomorphic. -/
@[simps]
def Matrix.dualNumberEquiv : Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R) 
goal: Matrix.dualNumberEquiv A =
  (Matrix.of fun i j => TrivSqZeroExt.fst (A i j), Matrix.of fun i j => TrivSqZeroExt.snd (A i j))
File: Mathlib/Data/QPF/Multivariate/Constructions/Prj.lean

full_name: MvQPF.Prj
code: /-- The projection `i` functor -/
def Prj (v : TypeVec.{u} n) : Type u 
goal: Type u

full_name: MvQPF.Prj.inhabited
code: instance Prj.inhabited {v : TypeVec.{u} n} [Inhabited (v i)] : Inhabited (Prj i v) 
goal: Inhabited (MvQPF.Prj i v)

full_name: MvQPF.Prj.map
code: /-- `map` on functor `Prj i` -/
def Prj.map ⦃α β : TypeVec n⦄ (f : α ⟹ β) : Prj i α → Prj i β 
goal: MvQPF.Prj i α → MvQPF.Prj i β

full_name: MvQPF.Prj.mvfunctor
code: instance Prj.mvfunctor : MvFunctor (Prj i) 
goal: MvFunctor (MvQPF.Prj i)

full_name: MvQPF.Prj.P
code: /-- Polynomial representation of the projection functor -/
def Prj.P : MvPFunctor.{u} n 
goal: MvPFunctor.{u} n

full_name: MvQPF.Prj.abs
code: /-- Abstraction function of the `QPF` instance -/
def Prj.abs ⦃α : TypeVec n⦄ : Prj.P i α → Prj i α
  
goal: ↑(MvQPF.Prj.P i) α → MvQPF.Prj i α

full_name: MvQPF.Prj.repr
code: /-- Representation function of the `QPF` instance -/
def Prj.repr ⦃α : TypeVec n⦄ : Prj i α → Prj.P i α 
goal: MvQPF.Prj i α → ↑(MvQPF.Prj.P i) α

full_name: MvQPF.Prj.mvqpf
code: instance Prj.mvqpf : MvQPF (Prj i) 
goal: MvQPF (MvQPF.Prj i)
File: Mathlib/Data/QPF/Multivariate/Constructions/Quot.lean

full_name: MvQPF.quotientQPF
code: /-- If `F` is a QPF then `G` is a QPF as well. Can be used to
construct `MvQPF` instances by transporting them across
surjective functions -/
def quotientQPF (FG_abs_repr : ∀ {α} (x : G α), FG_abs (FG_repr x) = x)
    (FG_abs_map : ∀ {α β} (f : α ⟹ β) (x : F α), FG_abs (f <$$> x) = f <$$> FG_abs x) :
    MvQPF G 
goal: MvQPF G

full_name: MvQPF.Quot1
code: /-- Functorial quotient type -/
def Quot1 (α : TypeVec n) 
goal: Type u

full_name: MvQPF.Quot1.inhabited
code: instance Quot1.inhabited {α : TypeVec n} [Inhabited <| F α] : Inhabited (Quot1 R α) 
goal: Inhabited (MvQPF.Quot1 R α)

full_name: MvQPF.Quot1.map
code: /-- `map` of the `Quot1` functor -/
def Quot1.map ⦃α β⦄ (f : α ⟹ β) : Quot1.{u} R α → Quot1.{u} R β 
goal: MvQPF.Quot1 R α → MvQPF.Quot1 R β

full_name: MvQPF.Quot1.mvFunctor
code: /-- `mvFunctor` instance for `Quot1` with well-behaved `R` -/
def Quot1.mvFunctor : MvFunctor (Quot1 R) 
goal: MvFunctor (MvQPF.Quot1 R)

full_name: MvQPF.relQuot
code: /-- `Quot1` is a QPF -/
noncomputable def relQuot : @MvQPF _ (Quot1 R) 
goal: MvQPF (MvQPF.Quot1 R)