ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- RingHom.map_rat_algebraMap
@[simp]
theorem map_rat_algebraMap [Semiring R] [Semiring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S)
    (r : ℚ) : f (algebraMap ℚ R r) = algebraMap ℚ S r 
Arguments: {R : Type u_1} {S : Type u_2} [Semiring R] [Semiring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S) (r : ℚ)
Goal: f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r
-- algebraMap_rat_rat
@[simp] theorem algebraMap_rat_rat : algebraMap ℚ ℚ = RingHom.id ℚ 
Goal: algebraMap ℚ ℚ = RingHom.id ℚ
-- Pi.zero_apply
@[to_additive (attr := simp, nolint simpNF)]
theorem one_apply [∀ i, One <| f i] : (1 : ∀ i, f i) i = 1 
Arguments: {I : Type u} {f : I → Type v₁} (i : I) [(i : I) → Zero (f i)]
Goal: 0 i = 0
-- Pi.one_apply
@[to_additive (attr := simp, nolint simpNF)]
theorem one_apply [∀ i, One <| f i] : (1 : ∀ i, f i) i = 1 
Arguments: {I : Type u} {f : I → Type v₁} (i : I) [(i : I) → One (f i)]
Goal: 1 i = 1
-- Pi.one_def
@[to_additive]
theorem one_def [∀ i, One <| f i] : (1 : ∀ i, f i) = fun _ => 1 
Arguments: {I : Type u} {f : I → Type v₁} [(i : I) → One (f i)]
Goal: 1 = fun x => 1
-- Pi.zero_def
@[to_additive]
theorem one_def [∀ i, One <| f i] : (1 : ∀ i, f i) = fun _ => 1 
Arguments: {I : Type u} {f : I → Type v₁} [(i : I) → Zero (f i)]
Goal: 0 = fun x => 0
-- Function.const_zero
@[to_additive (attr := simp)] lemma _root_.Function.const_one [One β] : const α (1 : β) = 1 
Arguments: {α : Type u_1} {β : Type u_2} [Zero β]
Goal: Function.const α 0 = 0
-- Function.const_one
@[to_additive (attr := simp)] lemma _root_.Function.const_one [One β] : const α (1 : β) = 1 
Arguments: {α : Type u_1} {β : Type u_2} [One β]
Goal: Function.const α 1 = 1
-- Pi.one_comp
@[to_additive (attr := simp)]
theorem one_comp [One γ] (x : α → β) : (1 : β → γ) ∘ x = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One γ] (x : α → β)
Goal: 1 ∘ x = 1
-- Pi.zero_comp
@[to_additive (attr := simp)]
theorem one_comp [One γ] (x : α → β) : (1 : β → γ) ∘ x = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero γ] (x : α → β)
Goal: 0 ∘ x = 0
-- Pi.comp_zero
@[to_additive (attr := simp)]
theorem comp_one [One β] (x : β → γ) : x ∘ (1 : α → β) = const α (x 1) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero β] (x : β → γ)
Goal: x ∘ 0 = Function.const α (x 0)
-- Pi.comp_one
@[to_additive (attr := simp)]
theorem comp_one [One β] (x : β → γ) : x ∘ (1 : α → β) = const α (x 1) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One β] (x : β → γ)
Goal: x ∘ 1 = Function.const α (x 1)
-- Pi.add_apply
@[to_additive (attr := simp)]
theorem mul_apply [∀ i, Mul <| f i] : (x * y) i = x i * y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [(i : I) → Add (f i)]
Goal: (x + y) i = x i + y i
-- Pi.mul_apply
@[to_additive (attr := simp)]
theorem mul_apply [∀ i, Mul <| f i] : (x * y) i = x i * y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [(i : I) → Mul (f i)]
Goal: (x * y) i = x i * y i
-- Pi.mul_def
@[to_additive]
theorem mul_def [∀ i, Mul <| f i] : x * y = fun i => x i * y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) [(i : I) → Mul (f i)]
Goal: x * y = fun i => x i * y i
-- Pi.add_def
@[to_additive]
theorem mul_def [∀ i, Mul <| f i] : x * y = fun i => x i * y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) [(i : I) → Add (f i)]
Goal: x + y = fun i => x i + y i
-- Function.const_mul
@[to_additive (attr := simp)]
lemma _root_.Function.const_mul [Mul β] (a b : β) : const α a * const α b = const α (a * b) 
Arguments: {α : Type u_1} {β : Type u_2} [Mul β] (a b : β)
Goal: Function.const α a * Function.const α b = Function.const α (a * b)
-- Function.const_add
@[to_additive (attr := simp)]
lemma _root_.Function.const_mul [Mul β] (a b : β) : const α a * const α b = const α (a * b) 
Arguments: {α : Type u_1} {β : Type u_2} [Add β] (a b : β)
Goal: Function.const α a + Function.const α b = Function.const α (a + b)
-- Pi.mul_comp
@[to_additive]
theorem mul_comp [Mul γ] (x y : β → γ) (z : α → β) : (x * y) ∘ z = x ∘ z * y ∘ z 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Mul γ] (x y : β → γ) (z : α → β)
Goal: (x * y) ∘ z = x ∘ z * y ∘ z
-- Pi.add_comp
@[to_additive]
theorem mul_comp [Mul γ] (x y : β → γ) (z : α → β) : (x * y) ∘ z = x ∘ z * y ∘ z 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Add γ] (x y : β → γ) (z : α → β)
Goal: (x + y) ∘ z = x ∘ z + y ∘ z
-- Pi.smul_apply
@[to_additive (attr := simp, to_additive) (reorder := 5 6) smul_apply]
theorem pow_apply [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) (i : I) : (x ^ b) i = x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → SMul β (f i)] (b : β) (x : (i : I) → f i) (i : I)
Goal: (b • x) i = b • x i
-- Pi.vadd_apply
@[to_additive (attr := simp, to_additive) (reorder := 5 6) smul_apply]
theorem pow_apply [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) (i : I) : (x ^ b) i = x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → VAdd β (f i)] (b : β) (x : (i : I) → f i) (i : I)
Goal: (b +ᵥ x) i = b +ᵥ x i
-- Pi.pow_apply
@[to_additive (attr := simp, to_additive) (reorder := 5 6) smul_apply]
theorem pow_apply [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) (i : I) : (x ^ b) i = x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → Pow (f i) β] (x : (i : I) → f i) (b : β) (i : I)
Goal: (x ^ b) i = x i ^ b
-- Pi.smul_def
@[to_additive (attr := to_additive) (reorder := 5 6) smul_def]
theorem pow_def [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) : x ^ b = fun i => x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → SMul β (f i)] (b : β) (x : (i : I) → f i)
Goal: b • x = fun i => b • x i
-- Pi.pow_def
@[to_additive (attr := to_additive) (reorder := 5 6) smul_def]
theorem pow_def [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) : x ^ b = fun i => x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → Pow (f i) β] (x : (i : I) → f i) (b : β)
Goal: x ^ b = fun i => x i ^ b
-- Pi.vadd_def
@[to_additive (attr := to_additive) (reorder := 5 6) smul_def]
theorem pow_def [∀ i, Pow (f i) β] (x : ∀ i, f i) (b : β) : x ^ b = fun i => x i ^ b 
Arguments: {I : Type u} {β : Type u_2} {f : I → Type v₁} [(i : I) → VAdd β (f i)] (b : β) (x : (i : I) → f i)
Goal: b +ᵥ x = fun i => b +ᵥ x i
-- Function.const_pow
@[to_additive (attr := simp, to_additive) (reorder := 2 3, 5 6) smul_const]
lemma _root_.Function.const_pow [Pow α β] (a : α) (b : β) : const I a ^ b = const I (a ^ b) 
Arguments: {I : Type u} {α : Type u_1} {β : Type u_2} [Pow α β] (a : α) (b : β)
Goal: Function.const I a ^ b = Function.const I (a ^ b)
-- Function.smul_const
@[to_additive (attr := simp, to_additive) (reorder := 2 3, 5 6) smul_const]
lemma _root_.Function.const_pow [Pow α β] (a : α) (b : β) : const I a ^ b = const I (a ^ b) 
Arguments: {I : Type u} {β : Type u_2} {α : Type u_1} [SMul β α] (b : β) (a : α)
Goal: b • Function.const I a = Function.const I (b • a)
-- Function.vadd_const
@[to_additive (attr := simp, to_additive) (reorder := 2 3, 5 6) smul_const]
lemma _root_.Function.const_pow [Pow α β] (a : α) (b : β) : const I a ^ b = const I (a ^ b) 
Arguments: {I : Type u} {β : Type u_2} {α : Type u_1} [VAdd β α] (b : β) (a : α)
Goal: b +ᵥ Function.const I a = Function.const I (b +ᵥ a)
-- Pi.pow_comp
@[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
Arguments: {I : Type u} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Pow γ α] (x : β → γ) (a : α) (y : I → β)
Goal: (x ^ a) ∘ y = x ∘ y ^ a
-- Pi.vadd_comp
@[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
Arguments: {I : Type u} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [VAdd α γ] (a : α) (x : β → γ) (y : I → β)
Goal: (a +ᵥ x) ∘ y = a +ᵥ x ∘ y
-- Pi.smul_comp
@[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
Arguments: {I : Type u} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [SMul α γ] (a : α) (x : β → γ) (y : I → β)
Goal: (a • x) ∘ y = a • x ∘ y
-- Pi.neg_apply
@[to_additive (attr := simp)]
theorem inv_apply [∀ i, Inv <| f i] : x⁻¹ i = (x i)⁻¹ 
Arguments: {I : Type u} {f : I → Type v₁} (x : (i : I) → f i) (i : I) [(i : I) → Neg (f i)]
Goal: (-x) i = -x i
-- Pi.inv_apply
@[to_additive (attr := simp)]
theorem inv_apply [∀ i, Inv <| f i] : x⁻¹ i = (x i)⁻¹ 
Arguments: {I : Type u} {f : I → Type v₁} (x : (i : I) → f i) (i : I) [(i : I) → Inv (f i)]
Goal: x⁻¹ i = (x i)⁻¹
-- Pi.inv_def
@[to_additive]
theorem inv_def [∀ i, Inv <| f i] : x⁻¹ = fun i => (x i)⁻¹ 
Arguments: {I : Type u} {f : I → Type v₁} (x : (i : I) → f i) [(i : I) → Inv (f i)]
Goal: x⁻¹ = fun i => (x i)⁻¹
-- Pi.neg_def
@[to_additive]
theorem inv_def [∀ i, Inv <| f i] : x⁻¹ = fun i => (x i)⁻¹ 
Arguments: {I : Type u} {f : I → Type v₁} (x : (i : I) → f i) [(i : I) → Neg (f i)]
Goal: -x = fun i => -x i
-- Function.const_neg
@[to_additive]
lemma _root_.Function.const_inv [Inv β] (a : β) : (const α a)⁻¹ = const α a⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [Neg β] (a : β)
Goal: -Function.const α a = Function.const α (-a)
-- Function.const_inv
@[to_additive]
lemma _root_.Function.const_inv [Inv β] (a : β) : (const α a)⁻¹ = const α a⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [Inv β] (a : β)
Goal: (Function.const α a)⁻¹ = Function.const α a⁻¹
-- Pi.neg_comp
@[to_additive]
theorem inv_comp [Inv γ] (x : β → γ) (y : α → β) : x⁻¹ ∘ y = (x ∘ y)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Neg γ] (x : β → γ) (y : α → β)
Goal: (-x) ∘ y = -x ∘ y
-- Pi.inv_comp
@[to_additive]
theorem inv_comp [Inv γ] (x : β → γ) (y : α → β) : x⁻¹ ∘ y = (x ∘ y)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Inv γ] (x : β → γ) (y : α → β)
Goal: x⁻¹ ∘ y = (x ∘ y)⁻¹
-- Pi.sub_apply
@[to_additive (attr := simp)]
theorem div_apply [∀ i, Div <| f i] : (x / y) i = x i / y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [(i : I) → Sub (f i)]
Goal: (x - y) i = x i - y i
-- Pi.div_apply
@[to_additive (attr := simp)]
theorem div_apply [∀ i, Div <| f i] : (x / y) i = x i / y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [(i : I) → Div (f i)]
Goal: (x / y) i = x i / y i
-- Pi.sub_def
@[to_additive]
theorem div_def [∀ i, Div <| f i] : x / y = fun i => x i / y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) [(i : I) → Sub (f i)]
Goal: x - y = fun i => x i - y i
-- Pi.div_def
@[to_additive]
theorem div_def [∀ i, Div <| f i] : x / y = fun i => x i / y i 
Arguments: {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) [(i : I) → Div (f i)]
Goal: x / y = fun i => x i / y i
-- Pi.div_comp
@[to_additive]
theorem div_comp [Div γ] (x y : β → γ) (z : α → β) : (x / y) ∘ z = x ∘ z / y ∘ z 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Div γ] (x y : β → γ) (z : α → β)
Goal: (x / y) ∘ z = x ∘ z / y ∘ z
-- Pi.sub_comp
@[to_additive]
theorem div_comp [Div γ] (x y : β → γ) (z : α → β) : (x / y) ∘ z = x ∘ z / y ∘ z 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Sub γ] (x y : β → γ) (z : α → β)
Goal: (x - y) ∘ z = x ∘ z - y ∘ z
-- Function.const_sub
@[to_additive (attr := simp)]
lemma _root_.Function.const_div [Div β] (a b : β) : const α a / const α b = const α (a / b) 
Arguments: {α : Type u_1} {β : Type u_2} [Sub β] (a b : β)
Goal: Function.const α a - Function.const α b = Function.const α (a - b)
-- Function.const_div
@[to_additive (attr := simp)]
lemma _root_.Function.const_div [Div β] (a b : β) : const α a / const α b = const α (a / b) 
Arguments: {α : Type u_1} {β : Type u_2} [Div β] (a b : β)
Goal: Function.const α a / Function.const α b = Function.const α (a / b)
-- Pi.single_eq_same
@[to_additive (attr := simp)]
theorem mulSingle_eq_same (i : I) (x : f i) : mulSingle i x i = x 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] (i : I) (x : f i)
Goal: Pi.single i x i = x
-- Pi.mulSingle_eq_same
@[to_additive (attr := simp)]
theorem mulSingle_eq_same (i : I) (x : f i) : mulSingle i x i = x 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] (i : I) (x : f i)
Goal: Pi.mulSingle i x i = x
-- Pi.mulSingle_eq_of_ne
@[to_additive (attr := simp)]
theorem mulSingle_eq_of_ne {i i' : I} (h : i' ≠ i) (x : f i) : mulSingle i x i' = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] {i i' : I} (h : i' ≠ i) (x : f i)
Goal: Pi.mulSingle i x i' = 1
-- Pi.single_eq_of_ne
@[to_additive (attr := simp)]
theorem mulSingle_eq_of_ne {i i' : I} (h : i' ≠ i) (x : f i) : mulSingle i x i' = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] {i i' : I} (h : i' ≠ i) (x : f i)
Goal: Pi.single i x i' = 0
-- Pi.single_eq_of_ne'
@[to_additive (attr := simp)
  "Abbreviation for `single_eq_of_ne h.symm`, for ease of use by `simp`."]
theorem mulSingle_eq_of_ne' {i i' : I} (h : i ≠ i') (x : f i) : mulSingle i x i' = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] {i i' : I} (h : i ≠ i') (x : f i)
Goal: Pi.single i x i' = 0
-- Pi.mulSingle_eq_of_ne'
@[to_additive (attr := simp)
  "Abbreviation for `single_eq_of_ne h.symm`, for ease of use by `simp`."]
theorem mulSingle_eq_of_ne' {i i' : I} (h : i ≠ i') (x : f i) : mulSingle i x i' = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] {i i' : I} (h : i ≠ i') (x : f i)
Goal: Pi.mulSingle i x i' = 1
-- Pi.single_zero
@[to_additive (attr := simp)]
theorem mulSingle_one (i : I) : mulSingle i (1 : f i) = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] (i : I)
Goal: Pi.single i 0 = 0
-- Pi.mulSingle_one
@[to_additive (attr := simp)]
theorem mulSingle_one (i : I) : mulSingle i (1 : f i) = 1 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] (i : I)
Goal: Pi.mulSingle i 1 = 1
-- Pi.mulSingle_apply
@[to_additive "On non-dependent functions, `Pi.single` can be expressed as an `ite`"]
theorem mulSingle_apply [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = if i' = i then x else 1 
Arguments: {I : Type u} {β : Type u_2} [DecidableEq I] [One β] (i : I) (x : β) (i' : I)
Goal: Pi.mulSingle i x i' = if i' = i then x else 1
-- Pi.single_apply
@[to_additive "On non-dependent functions, `Pi.single` can be expressed as an `ite`"]
theorem mulSingle_apply [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = if i' = i then x else 1 
Arguments: {I : Type u} {β : Type u_2} [DecidableEq I] [Zero β] (i : I) (x : β) (i' : I)
Goal: Pi.single i x i' = if i' = i then x else 0
-- Pi.single_comm
@[to_additive "On non-dependent functions, `Pi.single` is symmetric in the two indices."]
theorem mulSingle_comm [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = (mulSingle i' x : I → β) i 
Arguments: {I : Type u} {β : Type u_2} [DecidableEq I] [Zero β] (i : I) (x : β) (i' : I)
Goal: Pi.single i x i' = Pi.single i' x i
-- Pi.mulSingle_comm
@[to_additive "On non-dependent functions, `Pi.single` is symmetric in the two indices."]
theorem mulSingle_comm [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = (mulSingle i' x : I → β) i 
Arguments: {I : Type u} {β : Type u_2} [DecidableEq I] [One β] (i : I) (x : β) (i' : I)
Goal: Pi.mulSingle i x i' = Pi.mulSingle i' x i
-- Pi.apply_mulSingle
@[to_additive]
theorem apply_mulSingle (f' : ∀ i, f i → g i) (hf' : ∀ i, f' i 1 = 1) (i : I) (x : f i) (j : I) :
    f' j (mulSingle i x j) = mulSingle i (f' i x) j 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} [DecidableEq I] [(i : I) → One (f i)] [(i : I) → One (g i)] (f' : (i : I) → f i → g i) (hf' : ∀ (i : I), f' i 1 = 1) (i : I) (x : f i) (j : I)
Goal: f' j (Pi.mulSingle i x j) = Pi.mulSingle i (f' i x) j
-- Pi.apply_single
@[to_additive]
theorem apply_mulSingle (f' : ∀ i, f i → g i) (hf' : ∀ i, f' i 1 = 1) (i : I) (x : f i) (j : I) :
    f' j (mulSingle i x j) = mulSingle i (f' i x) j 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} [DecidableEq I] [(i : I) → Zero (f i)] [(i : I) → Zero (g i)] (f' : (i : I) → f i → g i) (hf' : ∀ (i : I), f' i 0 = 0) (i : I) (x : f i) (j : I)
Goal: f' j (Pi.single i x j) = Pi.single i (f' i x) j
-- Pi.apply_single₂
@[to_additive apply_single₂]
theorem apply_mulSingle₂ (f' : ∀ i, f i → g i → h i) (hf' : ∀ i, f' i 1 1 = 1) (i : I)
    (x : f i) (y : g i) (j : I) :
    f' j (mulSingle i x j) (mulSingle i y j) = mulSingle i (f' i x y) j 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} {h : I → Type v₃} [DecidableEq I] [(i : I) → Zero (f i)] [(i : I) → Zero (g i)] [(i : I) → Zero (h i)] (f' : (i : I) → f i → g i → h i) (hf' : ∀ (i : I), f' i 0 0 = 0) (i : I) (x : f i) (y : g i) (j : I)
Goal: f' j (Pi.single i x j) (Pi.single i y j) = Pi.single i (f' i x y) j
-- Pi.apply_mulSingle₂
@[to_additive apply_single₂]
theorem apply_mulSingle₂ (f' : ∀ i, f i → g i → h i) (hf' : ∀ i, f' i 1 1 = 1) (i : I)
    (x : f i) (y : g i) (j : I) :
    f' j (mulSingle i x j) (mulSingle i y j) = mulSingle i (f' i x y) j 
Arguments: {I : Type u} {f : I → Type v₁} {g : I → Type v₂} {h : I → Type v₃} [DecidableEq I] [(i : I) → One (f i)] [(i : I) → One (g i)] [(i : I) → One (h i)] (f' : (i : I) → f i → g i → h i) (hf' : ∀ (i : I), f' i 1 1 = 1) (i : I) (x : f i) (y : g i) (j : I)
Goal: f' j (Pi.mulSingle i x j) (Pi.mulSingle i y j) = Pi.mulSingle i (f' i x y) j
-- Pi.single_op
@[to_additive]
theorem mulSingle_op {g : I → Type*} [∀ i, One (g i)] (op : ∀ i, f i → g i)
    (h : ∀ i, op i 1 = 1) (i : I) (x : f i) :
    mulSingle i (op i x) = fun j => op j (mulSingle i x j) 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] {g : I → Type u_4} [(i : I) → Zero (g i)] (op : (i : I) → f i → g i) (h : ∀ (i : I), op i 0 = 0) (i : I) (x : f i)
Goal: Pi.single i (op i x) = fun j => op j (Pi.single i x j)
-- Pi.mulSingle_op
@[to_additive]
theorem mulSingle_op {g : I → Type*} [∀ i, One (g i)] (op : ∀ i, f i → g i)
    (h : ∀ i, op i 1 = 1) (i : I) (x : f i) :
    mulSingle i (op i x) = fun j => op j (mulSingle i x j) 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] {g : I → Type u_4} [(i : I) → One (g i)] (op : (i : I) → f i → g i) (h : ∀ (i : I), op i 1 = 1) (i : I) (x : f i)
Goal: Pi.mulSingle i (op i x) = fun j => op j (Pi.mulSingle i x j)
-- Pi.mulSingle_op₂
@[to_additive]
theorem mulSingle_op₂ {g₁ g₂ : I → Type*} [∀ i, One (g₁ i)] [∀ i, One (g₂ i)]
    (op : ∀ i, g₁ i → g₂ i → f i) (h : ∀ i, op i 1 1 = 1) (i : I) (x₁ : g₁ i) (x₂ : g₂ i) :
    mulSingle i (op i x₁ x₂) = fun j => op j (mulSingle i x₁ j) (mulSingle i x₂ j) 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → One (f i)] {g₁ : I → Type u_4} {g₂ : I → Type u_5} [(i : I) → One (g₁ i)] [(i : I) → One (g₂ i)] (op : (i : I) → g₁ i → g₂ i → f i) (h : ∀ (i : I), op i 1 1 = 1) (i : I) (x₁ : g₁ i) (x₂ : g₂ i)
Goal: Pi.mulSingle i (op i x₁ x₂) = fun j => op j (Pi.mulSingle i x₁ j) (Pi.mulSingle i x₂ j)
-- Pi.single_op₂
@[to_additive]
theorem mulSingle_op₂ {g₁ g₂ : I → Type*} [∀ i, One (g₁ i)] [∀ i, One (g₂ i)]
    (op : ∀ i, g₁ i → g₂ i → f i) (h : ∀ i, op i 1 1 = 1) (i : I) (x₁ : g₁ i) (x₂ : g₂ i) :
    mulSingle i (op i x₁ x₂) = fun j => op j (mulSingle i x₁ j) (mulSingle i x₂ j) 
Arguments: {I : Type u} {f : I → Type v₁} [DecidableEq I] [(i : I) → Zero (f i)] {g₁ : I → Type u_4} {g₂ : I → Type u_5} [(i : I) → Zero (g₁ i)] [(i : I) → Zero (g₂ i)] (op : (i : I) → g₁ i → g₂ i → f i) (h : ∀ (i : I), op i 0 0 = 0) (i : I) (x₁ : g₁ i) (x₂ : g₂ i)
Goal: Pi.single i (op i x₁ x₂) = fun j => op j (Pi.single i x₁ j) (Pi.single i x₂ j)
-- Pi.mulSingle_injective
@[to_additive]
theorem mulSingle_injective (i : I) : Function.Injective (mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} (f : I → Type v₁) [DecidableEq I] [(i : I) → One (f i)] (i : I)
Goal: Function.Injective (Pi.mulSingle i)
-- Pi.single_injective
@[to_additive]
theorem mulSingle_injective (i : I) : Function.Injective (mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} (f : I → Type v₁) [DecidableEq I] [(i : I) → Zero (f i)] (i : I)
Goal: Function.Injective (Pi.single i)
-- Pi.mulSingle_inj
@[to_additive (attr := simp)]
theorem mulSingle_inj (i : I) {x y : f i} : mulSingle i x = mulSingle i y ↔ x = y 
Arguments: {I : Type u} (f : I → Type v₁) [DecidableEq I] [(i : I) → One (f i)] (i : I) {x y : f i}
Goal: Pi.mulSingle i x = Pi.mulSingle i y ↔ x = y
-- Pi.single_inj
@[to_additive (attr := simp)]
theorem mulSingle_inj (i : I) {x y : f i} : mulSingle i x = mulSingle i y ↔ x = y 
Arguments: {I : Type u} (f : I → Type v₁) [DecidableEq I] [(i : I) → Zero (f i)] (i : I) {x y : f i}
Goal: Pi.single i x = Pi.single i y ↔ x = y
-- Pi.prod_fst_snd
theorem prod_fst_snd : Pi.prod (Prod.fst : α × β → α) (Prod.snd : α × β → β) = id 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Pi.prod Prod.fst Prod.snd = id
-- Pi.prod_snd_fst
theorem prod_snd_fst : Pi.prod (Prod.snd : α × β → β) (Prod.fst : α × β → α) = Prod.swap 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Pi.prod Prod.snd Prod.fst = Prod.swap
-- Function.extend_zero
@[to_additive]
theorem extend_one [One γ] (f : α → β) : Function.extend f (1 : α → γ) (1 : β → γ) = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Zero γ] (f : α → β)
Goal: Function.extend f 0 0 = 0
-- Function.extend_one
@[to_additive]
theorem extend_one [One γ] (f : α → β) : Function.extend f (1 : α → γ) (1 : β → γ) = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [One γ] (f : α → β)
Goal: Function.extend f 1 1 = 1
-- Function.extend_mul
@[to_additive]
theorem extend_mul [Mul γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
    Function.extend f (g₁ * g₂) (e₁ * e₂) = Function.extend f g₁ e₁ * Function.extend f g₂ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Mul γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ)
Goal: Function.extend f (g₁ * g₂) (e₁ * e₂) = Function.extend f g₁ e₁ * Function.extend f g₂ e₂
-- Function.extend_add
@[to_additive]
theorem extend_mul [Mul γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
    Function.extend f (g₁ * g₂) (e₁ * e₂) = Function.extend f g₁ e₁ * Function.extend f g₂ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Add γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ)
Goal: Function.extend f (g₁ + g₂) (e₁ + e₂) = Function.extend f g₁ e₁ + Function.extend f g₂ e₂
-- Function.extend_inv
@[to_additive]
theorem extend_inv [Inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
    Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Inv γ] (f : α → β) (g : α → γ) (e : β → γ)
Goal: Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹
-- Function.extend_neg
@[to_additive]
theorem extend_inv [Inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
    Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Neg γ] (f : α → β) (g : α → γ) (e : β → γ)
Goal: Function.extend f (-g) (-e) = -Function.extend f g e
-- Function.extend_sub
@[to_additive]
theorem extend_div [Div γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
    Function.extend f (g₁ / g₂) (e₁ / e₂) = Function.extend f g₁ e₁ / Function.extend f g₂ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Sub γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ)
Goal: Function.extend f (g₁ - g₂) (e₁ - e₂) = Function.extend f g₁ e₁ - Function.extend f g₂ e₂
-- Function.extend_div
@[to_additive]
theorem extend_div [Div γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
    Function.extend f (g₁ / g₂) (e₁ / e₂) = Function.extend f g₁ e₁ / Function.extend f g₂ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Div γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ)
Goal: Function.extend f (g₁ / g₂) (e₁ / e₂) = Function.extend f g₁ e₁ / Function.extend f g₂ e₂
-- Function.surjective_pi_map
theorem surjective_pi_map {F : ∀ i, f i → g i} (hF : ∀ i, Surjective (F i)) :
    Surjective 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.Surjective (F i))
Goal: Function.Surjective fun x i => F i (x i)