ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.injective_pi_map
theorem injective_pi_map {F : ∀ i, f i → g i} (hF : ∀ i, Injective (F i)) :
    Injective fun x : ∀ i, f i => fun i => F i (x i) 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} {F : (i : I) → f i → g i} (hF : ∀ (i : I), Function.Injective (F i))
Goal: Function.Injective fun x i => F i (x i)
-- Function.bijective_pi_map
theorem bijective_pi_map {F : ∀ i, f i → g i} (hF : ∀ i, Bijective (F i)) :
    Bijective fun x : ∀ i, f i => fun i => F i (x i) 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} {F : (i : I) → f i → g i} (hF : ∀ (i : I), Function.Bijective (F i))
Goal: Function.Bijective fun x i => F i (x i)
-- Function.comp_eq_const_iff
lemma comp_eq_const_iff (b : β) (f : α → β) {g : β → γ} (hg : Injective g) :
    g ∘ f = Function.const _ (g b) ↔ f = Function.const _ b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (b : β) (f : α → β) {g : β → γ} (hg : Function.Injective g)
Goal: g ∘ f = Function.const α (g b) ↔ f = Function.const α b
-- Function.comp_eq_one_iff
@[to_additive]
lemma comp_eq_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f = 1 ↔ f = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One β] [One γ] (f : α → β) {g : β → γ} (hg : Function.Injective g) (hg0 : g 1 = 1)
Goal: g ∘ f = 1 ↔ f = 1
-- Function.comp_eq_zero_iff
@[to_additive]
lemma comp_eq_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f = 1 ↔ f = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero β] [Zero γ] (f : α → β) {g : β → γ} (hg : Function.Injective g) (hg0 : g 0 = 0)
Goal: g ∘ f = 0 ↔ f = 0
-- Function.comp_ne_zero_iff
@[to_additive]
lemma comp_ne_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f ≠ 1 ↔ f ≠ 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero β] [Zero γ] (f : α → β) {g : β → γ} (hg : Function.Injective g) (hg0 : g 0 = 0)
Goal: g ∘ f ≠ 0 ↔ f ≠ 0
-- Function.comp_ne_one_iff
@[to_additive]
lemma comp_ne_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f ≠ 1 ↔ f ≠ 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One β] [One γ] (f : α → β) {g : β → γ} (hg : Function.Injective g) (hg0 : g 1 = 1)
Goal: g ∘ f ≠ 1 ↔ f ≠ 1
-- Subsingleton.pi_single_eq
@[to_additive]
theorem Subsingleton.pi_mulSingle_eq {α : Type*} [DecidableEq I] [Subsingleton I] [One α]
    (i : I) (x : α) : Pi.mulSingle i x = fun _ => x 
Arguments: {I : Type u} {α : Type u_4} [DecidableEq I] [Subsingleton I] [Zero α] (i : I) (x : α)
Goal: Pi.single i x = fun x_1 => x
-- Subsingleton.pi_mulSingle_eq
@[to_additive]
theorem Subsingleton.pi_mulSingle_eq {α : Type*} [DecidableEq I] [Subsingleton I] [One α]
    (i : I) (x : α) : Pi.mulSingle i x = fun _ => x 
Arguments: {I : Type u} {α : Type u_4} [DecidableEq I] [Subsingleton I] [One α] (i : I) (x : α)
Goal: Pi.mulSingle i x = fun x_1 => x
-- Sum.elim_one_one
@[to_additive (attr := simp)]
theorem elim_one_one [One γ] : Sum.elim (1 : α → γ) (1 : β → γ) = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One γ]
Goal: Sum.elim 1 1 = 1
-- Sum.elim_zero_zero
@[to_additive (attr := simp)]
theorem elim_one_one [One γ] : Sum.elim (1 : α → γ) (1 : β → γ) = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero γ]
Goal: Sum.elim 0 0 = 0
-- Sum.elim_mulSingle_one
@[to_additive (attr := simp)]
theorem elim_mulSingle_one [DecidableEq α] [DecidableEq β] [One γ] (i : α) (c : γ) :
    Sum.elim (Pi.mulSingle i c) (1 : β → γ) = Pi.mulSingle (Sum.inl i) c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq α] [DecidableEq β] [One γ] (i : α) (c : γ)
Goal: Sum.elim (Pi.mulSingle i c) 1 = Pi.mulSingle (Sum.inl i) c
-- Sum.elim_single_zero
@[to_additive (attr := simp)]
theorem elim_mulSingle_one [DecidableEq α] [DecidableEq β] [One γ] (i : α) (c : γ) :
    Sum.elim (Pi.mulSingle i c) (1 : β → γ) = Pi.mulSingle (Sum.inl i) c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq α] [DecidableEq β] [Zero γ] (i : α) (c : γ)
Goal: Sum.elim (Pi.single i c) 0 = Pi.single (Sum.inl i) c
-- Sum.elim_zero_single
@[to_additive (attr := simp)]
theorem elim_one_mulSingle [DecidableEq α] [DecidableEq β] [One γ] (i : β) (c : γ) :
    Sum.elim (1 : α → γ) (Pi.mulSingle i c) = Pi.mulSingle (Sum.inr i) c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq α] [DecidableEq β] [Zero γ] (i : β) (c : γ)
Goal: Sum.elim 0 (Pi.single i c) = Pi.single (Sum.inr i) c
-- Sum.elim_one_mulSingle
@[to_additive (attr := simp)]
theorem elim_one_mulSingle [DecidableEq α] [DecidableEq β] [One γ] (i : β) (c : γ) :
    Sum.elim (1 : α → γ) (Pi.mulSingle i c) = Pi.mulSingle (Sum.inr i) c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq α] [DecidableEq β] [One γ] (i : β) (c : γ)
Goal: Sum.elim 1 (Pi.mulSingle i c) = Pi.mulSingle (Sum.inr i) c
-- Sum.elim_inv_inv
@[to_additive]
theorem elim_inv_inv [Inv γ] : Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α → γ) (b : β → γ) [Inv γ]
Goal: Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹
-- Sum.elim_neg_neg
@[to_additive]
theorem elim_inv_inv [Inv γ] : Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α → γ) (b : β → γ) [Neg γ]
Goal: Sum.elim (-a) (-b) = -Sum.elim a b
-- Sum.elim_add_add
@[to_additive]
theorem elim_mul_mul [Mul γ] : Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a a' : α → γ) (b b' : β → γ) [Add γ]
Goal: Sum.elim (a + a') (b + b') = Sum.elim a b + Sum.elim a' b'
-- Sum.elim_mul_mul
@[to_additive]
theorem elim_mul_mul [Mul γ] : Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a a' : α → γ) (b b' : β → γ) [Mul γ]
Goal: Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b'
-- Sum.elim_div_div
@[to_additive]
theorem elim_div_div [Div γ] : Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a a' : α → γ) (b b' : β → γ) [Div γ]
Goal: Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b'
-- Sum.elim_sub_sub
@[to_additive]
theorem elim_div_div [Div γ] : Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a a' : α → γ) (b b' : β → γ) [Sub γ]
Goal: Sum.elim (a - a') (b - b') = Sum.elim a b - Sum.elim a' b'
-- RestrictScalars.smul_def
theorem RestrictScalars.smul_def (c : R) (x : RestrictScalars R S M) :
    c • x = (RestrictScalars.addEquiv R S M).symm
      (algebraMap R S c • RestrictScalars.addEquiv R S M x) 
Arguments: (R : Type u_1) (S : Type u_2) (M : Type u_3) [AddCommMonoid M] [CommSemiring R] [Semiring S] [Algebra R S] [Module S M] (c : R) (x : RestrictScalars R S M)
Goal: c • x = (RestrictScalars.addEquiv R S M).symm ((algebraMap R S) c • (RestrictScalars.addEquiv R S M) x)
-- RestrictScalars.addEquiv_map_smul
@[simp]
theorem RestrictScalars.addEquiv_map_smul (c : R) (x : RestrictScalars R S M) :
    RestrictScalars.addEquiv R S M (c • x) = algebraMap R S c • RestrictScalars.addEquiv R S M x 
Arguments: (R : Type u_1) (S : Type u_2) (M : Type u_3) [AddCommMonoid M] [CommSemiring R] [Semiring S] [Algebra R S] [Module S M] (c : R) (x : RestrictScalars R S M)
Goal: (RestrictScalars.addEquiv R S M) (c • x) = (algebraMap R S) c • (RestrictScalars.addEquiv R S M) x
-- RestrictScalars.addEquiv_symm_map_algebraMap_smul
theorem RestrictScalars.addEquiv_symm_map_algebraMap_smul (r : R) (x : M) :
    (RestrictScalars.addEquiv R S M).symm (algebraMap R S r • x) =
      r • (RestrictScalars.addEquiv R S M).symm x 
Arguments: (R : Type u_1) (S : Type u_2) (M : Type u_3) [AddCommMonoid M] [CommSemiring R] [Semiring S] [Algebra R S] [Module S M] (r : R) (x : M)
Goal: (RestrictScalars.addEquiv R S M).symm ((algebraMap R S) r • x) = r • (RestrictScalars.addEquiv R S M).symm x
-- RestrictScalars.addEquiv_symm_map_smul_smul
theorem RestrictScalars.addEquiv_symm_map_smul_smul (r : R) (s : S) (x : M) :
    (RestrictScalars.addEquiv R S M).symm ((r • s) • x) =
      r • (RestrictScalars.addEquiv R S M).symm (s • x) 
Arguments: (R : Type u_1) (S : Type u_2) (M : Type u_3) [AddCommMonoid M] [CommSemiring R] [Semiring S] [Algebra R S] [Module S M] (r : R) (s : S) (x : M)
Goal: (RestrictScalars.addEquiv R S M).symm ((r • s) • x) = r • (RestrictScalars.addEquiv R S M).symm (s • x)
-- RestrictScalars.lsmul_apply_apply
theorem RestrictScalars.lsmul_apply_apply (s : S) (x : RestrictScalars R S M) :
    RestrictScalars.lsmul R S M s x =
      (RestrictScalars.addEquiv R S M).symm (s • RestrictScalars.addEquiv R S M x) 
Arguments: (R : Type u_1) (S : Type u_2) (M : Type u_3) [AddCommMonoid M] [CommSemiring R] [Semiring S] [Algebra R S] [Module S M] (s : S) (x : RestrictScalars R S M)
Goal: ((RestrictScalars.lsmul R S M) s) x = (RestrictScalars.addEquiv R S M).symm (s • (RestrictScalars.addEquiv R S M) x)
-- RestrictScalars.ringEquiv_map_smul
@[simp]
theorem RestrictScalars.ringEquiv_map_smul (r : R) (x : RestrictScalars R S A) :
    RestrictScalars.ringEquiv R S A (r • x) =
      algebraMap R S r • RestrictScalars.ringEquiv R S A x 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_4) [Semiring A] [CommSemiring S] [Algebra S A] [CommSemiring R] [Algebra R S] (r : R) (x : RestrictScalars R S A)
Goal: (RestrictScalars.ringEquiv R S A) (r • x) = (algebraMap R S) r • (RestrictScalars.ringEquiv R S A) x
-- RestrictScalars.ringEquiv_algebraMap
@[simp]
theorem RestrictScalars.ringEquiv_algebraMap (r : R) :
    RestrictScalars.ringEquiv R S A (algebraMap R (RestrictScalars R S A) r) =
      algebraMap S A (algebraMap R S r) 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_4) [Semiring A] [CommSemiring S] [Algebra S A] [CommSemiring R] [Algebra R S] (r : R)
Goal: (RestrictScalars.ringEquiv R S A) ((algebraMap R (RestrictScalars R S A)) r) = (algebraMap S A) ((algebraMap R S) r)
-- Set.range_one
@[to_additive (attr := simp)]
theorem Set.range_one {α β : Type*} [One β] [Nonempty α] : Set.range (1 : α → β) = {1} 
Arguments: {α : Type u_3} {β : Type u_4} [One β] [Nonempty α]
Goal: Set.range 1 = {1}
-- Set.range_zero
@[to_additive (attr := simp)]
theorem Set.range_one {α β : Type*} [One β] [Nonempty α] : Set.range (1 : α → β) = {1} 
Arguments: {α : Type u_3} {β : Type u_4} [Zero β] [Nonempty α]
Goal: Set.range 0 = {0}
-- Set.preimage_zero
@[to_additive]
theorem Set.preimage_one {α β : Type*} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
    (1 : α → β) ⁻¹' s = if (1 : β) ∈ s then Set.univ else ∅ 
Arguments: {α : Type u_3} {β : Type u_4} [Zero β] (s : Set β) [Decidable (0 ∈ s)]
Goal: 0 ⁻¹' s = if 0 ∈ s then Set.univ else ∅
-- Set.preimage_one
@[to_additive]
theorem Set.preimage_one {α β : Type*} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
    (1 : α → β) ⁻¹' s = if (1 : β) ∈ s then Set.univ else ∅ 
Arguments: {α : Type u_3} {β : Type u_4} [One β] (s : Set β) [Decidable (1 ∈ s)]
Goal: 1 ⁻¹' s = if 1 ∈ s then Set.univ else ∅
-- MulHom.coe_mul
@[to_additive]
theorem coe_mul {M N} {_ : Mul M} {_ : CommSemigroup N} (f g : M →ₙ* N) : (f * g : M → N) =
    fun x => f x * g x 
Arguments: {M : Type u_3} {N : Type u_4}
Goal: ∀ {x : Mul M} {x_1 : CommSemigroup N} (f g : M →ₙ* N), ⇑f * ⇑g = fun x_2 => f x_2 * g x_2
-- AddHom.coe_add
@[to_additive]
theorem coe_mul {M N} {_ : Mul M} {_ : CommSemigroup N} (f g : M →ₙ* N) : (f * g : M → N) =
    fun x => f x * g x 
Arguments: {M : Type u_3} {N : Type u_4}
Goal: ∀ {x : Add M} {x_1 : AddCommSemigroup N} (f g : AddHom M N), ⇑f + ⇑g = fun x_2 => f x_2 + g x_2
-- Pi.mulHom_apply
@[to_additive (attr := simps)
  "A family of AddHom's `f a : γ → β a` defines an AddHom `Pi.addHom f : γ → Π a, β a` given by
  `Pi.addHom f x b = f b x`."]
def Pi.mulHom {γ : Type w} [∀ i, Mul (f i)] [Mul γ] (g : ∀ i, γ →ₙ* f i) : γ →ₙ* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → Mul (f i)] [Mul γ] (g : (i : I) → γ →ₙ* f i) (x : γ) (i : I)
Goal: (Pi.mulHom g) x i = (g i) x
-- Pi.addHom_apply
@[to_additive (attr := simps)
  "A family of AddHom's `f a : γ → β a` defines an AddHom `Pi.addHom f : γ → Π a, β a` given by
  `Pi.addHom f x b = f b x`."]
def Pi.mulHom {γ : Type w} [∀ i, Mul (f i)] [Mul γ] (g : ∀ i, γ →ₙ* f i) : γ →ₙ* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → Add (f i)] [Add γ] (g : (i : I) → AddHom γ (f i)) (x : γ) (i : I)
Goal: (Pi.addHom g) x i = (g i) x
-- Pi.addHom_injective
@[to_additive]
theorem Pi.mulHom_injective {γ : Type w} [Nonempty I] [∀ i, Mul (f i)] [Mul γ] (g : ∀ i, γ →ₙ* f i)
    (hg : ∀ i, Function.Injective (g i)) : Function.Injective (Pi.mulHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → Add (f i)] [Add γ] (g : (i : I) → AddHom γ (f i)) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.addHom g)
-- Pi.mulHom_injective
@[to_additive]
theorem Pi.mulHom_injective {γ : Type w} [Nonempty I] [∀ i, Mul (f i)] [Mul γ] (g : ∀ i, γ →ₙ* f i)
    (hg : ∀ i, Function.Injective (g i)) : Function.Injective (Pi.mulHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → Mul (f i)] [Mul γ] (g : (i : I) → γ →ₙ* f i) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.mulHom g)
-- Pi.monoidHom_apply
@[to_additive (attr := simps)
  "A family of additive monoid homomorphisms `f a : γ →+ β a` defines a monoid homomorphism
  `Pi.addMonoidHom f : γ →+ Π a, β a` given by `Pi.addMonoidHom f x b = f b x`."]
def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g : ∀ i, γ →* f i) :
    γ →* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → MulOneClass (f i)] [MulOneClass γ] (g : (i : I) → γ →* f i) (x : γ) (i : I)
Goal: (Pi.monoidHom g) x i = (g i) x
-- Pi.addMonoidHom_apply
@[to_additive (attr := simps)
  "A family of additive monoid homomorphisms `f a : γ →+ β a` defines a monoid homomorphism
  `Pi.addMonoidHom f : γ →+ Π a, β a` given by `Pi.addMonoidHom f x b = f b x`."]
def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g : ∀ i, γ →* f i) :
    γ →* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → AddZeroClass (f i)] [AddZeroClass γ] (g : (i : I) → γ →+ f i) (x : γ) (i : I)
Goal: (Pi.addMonoidHom g) x i = (g i) x
-- Pi.monoidHom_injective
@[to_additive]
theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
    (g : ∀ i, γ →* f i) (hg : ∀ i, Function.Injective (g i)) :
    Function.Injective (Pi.monoidHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → MulOneClass (f i)] [MulOneClass γ] (g : (i : I) → γ →* f i) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.monoidHom g)
-- Pi.addMonoidHom_injective
@[to_additive]
theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
    (g : ∀ i, γ →* f i) (hg : ∀ i, Function.Injective (g i)) :
    Function.Injective (Pi.monoidHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → AddZeroClass (f i)] [AddZeroClass γ] (g : (i : I) → γ →+ f i) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.addMonoidHom g)
-- Pi.evalAddHom_apply
@[to_additive (attr := simps)
  "Evaluation of functions into an indexed collection of additive semigroups at a point is an
  additive semigroup homomorphism. This is `Function.eval i` as an `AddHom`."]
def Pi.evalMulHom (i : I) : (∀ i, f i) →ₙ* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → Add (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalAddHom f i) g = g i
-- Pi.evalMulHom_apply
@[to_additive (attr := simps)
  "Evaluation of functions into an indexed collection of additive semigroups at a point is an
  additive semigroup homomorphism. This is `Function.eval i` as an `AddHom`."]
def Pi.evalMulHom (i : I) : (∀ i, f i) →ₙ* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → Mul (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalMulHom f i) g = g i
-- Pi.constAddHom_apply
@[to_additive (attr := simps) "`Function.const` as an `AddHom`."]
def Pi.constMulHom (α β : Type*) [Mul β] :
    β →ₙ* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [Add β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constAddHom α β) a a_1 = Function.const α a a_1
-- Pi.constMulHom_apply
@[to_additive (attr := simps) "`Function.const` as an `AddHom`."]
def Pi.constMulHom (α β : Type*) [Mul β] :
    β →ₙ* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [Mul β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constMulHom α β) a a_1 = Function.const α a a_1
-- MulHom.coeFn_apply
@[to_additive (attr := simps) "Coercion of an `AddHom` into a function is itself an `AddHom`.

See also `AddHom.eval`."]
def MulHom.coeFn (α β : Type*) [Mul α] [CommSemigroup β] :
    (α →ₙ* β) →ₙ* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [Mul α] [CommSemigroup β] (g : α →ₙ* β) (a : α)
Goal: (MulHom.coeFn α β) g a = g a
-- AddHom.coeFn_apply
@[to_additive (attr := simps) "Coercion of an `AddHom` into a function is itself an `AddHom`.

See also `AddHom.eval`."]
def MulHom.coeFn (α β : Type*) [Mul α] [CommSemigroup β] :
    (α →ₙ* β) →ₙ* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [Add α] [AddCommSemigroup β] (g : AddHom α β) (a : α)
Goal: (AddHom.coeFn α β) g a = g a
-- AddHom.compLeft_apply
@[to_additive (attr := simps) "Additive semigroup homomorphism between the function spaces `I → α`
and `I → β`, induced by an additive semigroup homomorphism `f` between `α` and `β`"]
protected def MulHom.compLeft {α β : Type*} [Mul α] [Mul β] (f : α →ₙ* β) (I : Type*) :
    (I → α) →ₙ* I → β 
Arguments: {α : Type u_3} {β : Type u_4} [Add α] [Add β] (f : AddHom α β) (I : Type u_5) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- MulHom.compLeft_apply
@[to_additive (attr := simps) "Additive semigroup homomorphism between the function spaces `I → α`
and `I → β`, induced by an additive semigroup homomorphism `f` between `α` and `β`"]
protected def MulHom.compLeft {α β : Type*} [Mul α] [Mul β] (f : α →ₙ* β) (I : Type*) :
    (I → α) →ₙ* I → β 
Arguments: {α : Type u_3} {β : Type u_4} [Mul α] [Mul β] (f : α →ₙ* β) (I : Type u_5) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- Pi.evalMonoidHom_apply
@[to_additive (attr := simps) "Evaluation of functions into an indexed collection of additive
monoids at a point is an additive monoid homomorphism. This is `Function.eval i` as an
`AddMonoidHom`."]
def Pi.evalMonoidHom (i : I) : (∀ i, f i) →* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → MulOneClass (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalMonoidHom f i) g = g i
-- Pi.evalAddMonoidHom_apply
@[to_additive (attr := simps) "Evaluation of functions into an indexed collection of additive
monoids at a point is an additive monoid homomorphism. This is `Function.eval i` as an
`AddMonoidHom`."]
def Pi.evalMonoidHom (i : I) : (∀ i, f i) →* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → AddZeroClass (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalAddMonoidHom f i) g = g i
-- Pi.constMonoidHom_apply
@[to_additive (attr := simps) "`Function.const` as an `AddMonoidHom`."]
def Pi.constMonoidHom (α β : Type*) [MulOneClass β] : β →* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [MulOneClass β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constMonoidHom α β) a a_1 = Function.const α a a_1
-- Pi.constAddMonoidHom_apply
@[to_additive (attr := simps) "`Function.const` as an `AddMonoidHom`."]
def Pi.constMonoidHom (α β : Type*) [MulOneClass β] : β →* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [AddZeroClass β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constAddMonoidHom α β) a a_1 = Function.const α a a_1
-- MonoidHom.coeFn_apply
@[to_additive (attr := simps) "Coercion of an `AddMonoidHom` into a function is itself
an `AddMonoidHom`.

See also `AddMonoidHom.eval`."]
def MonoidHom.coeFn (α β : Type*) [MulOneClass α] [CommMonoid β] : (α →* β) →* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [MulOneClass α] [CommMonoid β] (g : α →* β) (a : α)
Goal: (MonoidHom.coeFn α β) g a = g a
-- AddMonoidHom.coeFn_apply
@[to_additive (attr := simps) "Coercion of an `AddMonoidHom` into a function is itself
an `AddMonoidHom`.

See also `AddMonoidHom.eval`."]
def MonoidHom.coeFn (α β : Type*) [MulOneClass α] [CommMonoid β] : (α →* β) →* α → β 
Arguments: (α : Type u_3) (β : Type u_4) [AddZeroClass α] [AddCommMonoid β] (g : α →+ β) (a : α)
Goal: (AddMonoidHom.coeFn α β) g a = g a
-- AddMonoidHom.compLeft_apply
@[to_additive (attr := simps)
  "Additive monoid homomorphism between the function spaces `I → α` and `I → β`, induced by an
  additive monoid homomorphism `f` between `α` and `β`"]
protected def MonoidHom.compLeft {α β : Type*} [MulOneClass α] [MulOneClass β] (f : α →* β)
    (I : Type*) : (I → α) →* I → β 
Arguments: {α : Type u_3} {β : Type u_4} [AddZeroClass α] [AddZeroClass β] (f : α →+ β) (I : Type u_5) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- MonoidHom.compLeft_apply
@[to_additive (attr := simps)
  "Additive monoid homomorphism between the function spaces `I → α` and `I → β`, induced by an
  additive monoid homomorphism `f` between `α` and `β`"]
protected def MonoidHom.compLeft {α β : Type*} [MulOneClass α] [MulOneClass β] (f : α →* β)
    (I : Type*) : (I → α) →* I → β 
Arguments: {α : Type u_3} {β : Type u_4} [MulOneClass α] [MulOneClass β] (f : α →* β) (I : Type u_5) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- ZeroHom.single_apply
@[to_additive (attr := simp)]
theorem OneHom.mulSingle_apply [∀ i, One <| f i] (i : I) (x : f i) :
    mulSingle f i x = Pi.mulSingle i x 
Arguments: {I : Type u} (f : I → Type v) [DecidableEq I] [(i : I) → Zero (f i)] (i : I) (x : f i)
Goal: (ZeroHom.single f i) x = Pi.single i x
-- OneHom.mulSingle_apply
@[to_additive (attr := simp)]
theorem OneHom.mulSingle_apply [∀ i, One <| f i] (i : I) (x : f i) :
    mulSingle f i x = Pi.mulSingle i x 
Arguments: {I : Type u} (f : I → Type v) [DecidableEq I] [(i : I) → One (f i)] (i : I) (x : f i)
Goal: (OneHom.mulSingle f i) x = Pi.mulSingle i x
-- MonoidHom.mulSingle_apply
@[to_additive (attr := simp)]
theorem MonoidHom.mulSingle_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
    mulSingle f i x = Pi.mulSingle i x 
Arguments: {I : Type u} (f : I → Type v) [DecidableEq I] [(i : I) → MulOneClass (f i)] (i : I) (x : f i)
Goal: (MonoidHom.mulSingle f i) x = Pi.mulSingle i x
-- AddMonoidHom.single_apply
@[to_additive (attr := simp)]
theorem MonoidHom.mulSingle_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
    mulSingle f i x = Pi.mulSingle i x 
Arguments: {I : Type u} (f : I → Type v) [DecidableEq I] [(i : I) → AddZeroClass (f i)] (i : I) (x : f i)
Goal: (AddMonoidHom.single f i) x = Pi.single i x
-- Pi.mulSingle_sup
@[to_additive]
theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
    Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → SemilatticeSup (f i)] [(i : I) → One (f i)] (i : I) (x y : f i)
Goal: Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y
-- Pi.single_sup
@[to_additive]
theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
    Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → SemilatticeSup (f i)] [(i : I) → Zero (f i)] (i : I) (x y : f i)
Goal: Pi.single i (x ⊔ y) = Pi.single i x ⊔ Pi.single i y
-- Pi.mulSingle_inf
@[to_additive]
theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
    Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → SemilatticeInf (f i)] [(i : I) → One (f i)] (i : I) (x y : f i)
Goal: Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y
-- Pi.single_inf
@[to_additive]
theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
    Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → SemilatticeInf (f i)] [(i : I) → Zero (f i)] (i : I) (x y : f i)
Goal: Pi.single i (x ⊓ y) = Pi.single i x ⊓ Pi.single i y