ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Pi.mulSingle_mul
@[to_additive]
theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
    mulSingle i (x * y) = mulSingle i x * mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → MulOneClass (f i)] (i : I) (x y : f i)
Goal: Pi.mulSingle i (x * y) = Pi.mulSingle i x * Pi.mulSingle i y
-- Pi.single_add
@[to_additive]
theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
    mulSingle i (x * y) = mulSingle i x * mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → AddZeroClass (f i)] (i : I) (x y : f i)
Goal: Pi.single i (x + y) = Pi.single i x + Pi.single i y
-- Pi.single_neg
@[to_additive]
theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
    mulSingle i x⁻¹ = (mulSingle i x)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → AddGroup (f i)] (i : I) (x : f i)
Goal: Pi.single i (-x) = -Pi.single i x
-- Pi.mulSingle_inv
@[to_additive]
theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
    mulSingle i x⁻¹ = (mulSingle i x)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → Group (f i)] (i : I) (x : f i)
Goal: Pi.mulSingle i x⁻¹ = (Pi.mulSingle i x)⁻¹
-- Pi.mulSingle_div
@[to_additive]
theorem Pi.mulSingle_div [∀ i, Group <| f i] (i : I) (x y : f i) :
    mulSingle i (x / y) = mulSingle i x / mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → Group (f i)] (i : I) (x y : f i)
Goal: Pi.mulSingle i (x / y) = Pi.mulSingle i x / Pi.mulSingle i y
-- Pi.single_sub
@[to_additive]
theorem Pi.mulSingle_div [∀ i, Group <| f i] (i : I) (x y : f i) :
    mulSingle i (x / y) = mulSingle i x / mulSingle i y 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → AddGroup (f i)] (i : I) (x y : f i)
Goal: Pi.single i (x - y) = Pi.single i x - Pi.single i y
-- Pi.single_addCommute
@[to_additive
      "The injection into an additive pi group at different indices commutes.

      For injections of commuting elements at the same index, see `AddCommute.map`"]
theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
    Pairwise fun i j => ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y) 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → AddZeroClass (f i)]
Goal: Pairwise fun i j => ∀ (x : f i) (y : f j), AddCommute (Pi.single i x) (Pi.single j y)
-- Pi.mulSingle_commute
@[to_additive
      "The injection into an additive pi group at different indices commutes.

      For injections of commuting elements at the same index, see `AddCommute.map`"]
theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
    Pairwise fun i j => ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y) 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → MulOneClass (f i)]
Goal: Pairwise fun i j => ∀ (x : f i) (y : f j), Commute (Pi.mulSingle i x) (Pi.mulSingle j y)
-- Pi.mulSingle_apply_commute
@[to_additive "The injection into an additive pi group with the same values commutes."]
theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i) (i j : I) :
    Commute (mulSingle i (x i)) (mulSingle j (x j)) 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → MulOneClass (f i)] (x : (i : I) → f i) (i j : I)
Goal: Commute (Pi.mulSingle i (x i)) (Pi.mulSingle j (x j))
-- Pi.single_apply_addCommute
@[to_additive "The injection into an additive pi group with the same values commutes."]
theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i) (i j : I) :
    Commute (mulSingle i (x i)) (mulSingle j (x j)) 
Arguments: {I : Type u} {f : I → Type v} [DecidableEq I] [(i : I) → AddZeroClass (f i)] (x : (i : I) → f i) (i j : I)
Goal: AddCommute (Pi.single i (x i)) (Pi.single j (x j))
-- Pi.update_eq_sub_add_single
@[to_additive]
theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i) (x : f i) :
    Function.update g i x = g / mulSingle i (g i) * mulSingle i x 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → AddGroup (f i)] (g : (i : I) → f i) (x : f i)
Goal: Function.update g i x = g - Pi.single i (g i) + Pi.single i x
-- Pi.update_eq_div_mul_mulSingle
@[to_additive]
theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i) (x : f i) :
    Function.update g i x = g / mulSingle i (g i) * mulSingle i x 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → Group (f i)] (g : (i : I) → f i) (x : f i)
Goal: Function.update g i x = g / Pi.mulSingle i (g i) * Pi.mulSingle i x
-- Pi.single_add_single_eq_single_add_single
@[to_additive]
theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type*} [CommMonoid M]
    {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1) :
    (mulSingle k u : I → M) * mulSingle l v = mulSingle m u * mulSingle n v ↔
      k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n 
Arguments: {I : Type u} [DecidableEq I] {M : Type u_3} [AddCommMonoid M] {k l m n : I} {u v : M} (hu : u ≠ 0) (hv : v ≠ 0)
Goal: Pi.single k u + Pi.single l v = Pi.single m u + Pi.single n v ↔
  k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
-- Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle
@[to_additive]
theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type*} [CommMonoid M]
    {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1) :
    (mulSingle k u : I → M) * mulSingle l v = mulSingle m u * mulSingle n v ↔
      k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n 
Arguments: {I : Type u} [DecidableEq I] {M : Type u_3} [CommMonoid M] {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1)
Goal: Pi.mulSingle k u * Pi.mulSingle l v = Pi.mulSingle m u * Pi.mulSingle n v ↔
  k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n
-- SemiconjBy.pi
@[to_additive]
theorem SemiconjBy.pi {x y z : ∀ i, f i} (h : ∀ i, SemiconjBy (x i) (y i) (z i)) :
    SemiconjBy x y z 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] {x y z : (i : I) → f i} (h : ∀ (i : I), SemiconjBy (x i) (y i) (z i))
Goal: SemiconjBy x y z
-- AddSemiconjBy.pi
@[to_additive]
theorem SemiconjBy.pi {x y z : ∀ i, f i} (h : ∀ i, SemiconjBy (x i) (y i) (z i)) :
    SemiconjBy x y z 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] {x y z : (i : I) → f i} (h : ∀ (i : I), AddSemiconjBy (x i) (y i) (z i))
Goal: AddSemiconjBy x y z
-- Pi.addSemiconjBy_iff
@[to_additive]
theorem Pi.semiconjBy_iff {x y z : ∀ i, f i} :
    SemiconjBy x y z ↔ ∀ i, SemiconjBy (x i) (y i) (z i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] {x y z : (i : I) → f i}
Goal: AddSemiconjBy x y z ↔ ∀ (i : I), AddSemiconjBy (x i) (y i) (z i)
-- Pi.semiconjBy_iff
@[to_additive]
theorem Pi.semiconjBy_iff {x y z : ∀ i, f i} :
    SemiconjBy x y z ↔ ∀ i, SemiconjBy (x i) (y i) (z i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] {x y z : (i : I) → f i}
Goal: SemiconjBy x y z ↔ ∀ (i : I), SemiconjBy (x i) (y i) (z i)
-- AddCommute.pi
@[to_additive]
theorem Commute.pi {x y : ∀ i, f i} (h : ∀ i, Commute (x i) (y i)) : Commute x y 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] {x y : (i : I) → f i} (h : ∀ (i : I), AddCommute (x i) (y i))
Goal: AddCommute x y
-- Commute.pi
@[to_additive]
theorem Commute.pi {x y : ∀ i, f i} (h : ∀ i, Commute (x i) (y i)) : Commute x y 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] {x y : (i : I) → f i} (h : ∀ (i : I), Commute (x i) (y i))
Goal: Commute x y
-- Pi.addCommute_iff
@[to_additive]
theorem Pi.commute_iff {x y : ∀ i, f i} : Commute x y ↔ ∀ i, Commute (x i) (y i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] {x y : (i : I) → f i}
Goal: AddCommute x y ↔ ∀ (i : I), AddCommute (x i) (y i)
-- Pi.commute_iff
@[to_additive]
theorem Pi.commute_iff {x y : ∀ i, f i} : Commute x y ↔ ∀ i, Commute (x i) (y i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] {x y : (i : I) → f i}
Goal: Commute x y ↔ ∀ (i : I), Commute (x i) (y i)
-- Function.update_one
@[to_additive (attr := simp)]
theorem update_one [∀ i, One (f i)] [DecidableEq I] (i : I) : update (1 : ∀ i, f i) i 1 = 1 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → One (f i)] [DecidableEq I] (i : I)
Goal: Function.update 1 i 1 = 1
-- Function.update_zero
@[to_additive (attr := simp)]
theorem update_one [∀ i, One (f i)] [DecidableEq I] (i : I) : update (1 : ∀ i, f i) i 1 = 1 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Zero (f i)] [DecidableEq I] (i : I)
Goal: Function.update 0 i 0 = 0
-- Function.update_add
@[to_additive]
theorem update_mul [∀ i, Mul (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (i : I) (x₁ : f i)
    (x₂ : f i) : update (f₁ * f₂) i (x₁ * x₂) = update f₁ i x₁ * update f₂ i x₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] [DecidableEq I] (f₁ f₂ : (i : I) → f i) (i : I) (x₁ x₂ : f i)
Goal: Function.update (f₁ + f₂) i (x₁ + x₂) = Function.update f₁ i x₁ + Function.update f₂ i x₂
-- Function.update_mul
@[to_additive]
theorem update_mul [∀ i, Mul (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (i : I) (x₁ : f i)
    (x₂ : f i) : update (f₁ * f₂) i (x₁ * x₂) = update f₁ i x₁ * update f₂ i x₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] [DecidableEq I] (f₁ f₂ : (i : I) → f i) (i : I) (x₁ x₂ : f i)
Goal: Function.update (f₁ * f₂) i (x₁ * x₂) = Function.update f₁ i x₁ * Function.update f₂ i x₂
-- Function.update_inv
@[to_additive]
theorem update_inv [∀ i, Inv (f i)] [DecidableEq I] (f₁ : ∀ i, f i) (i : I) (x₁ : f i) :
    update f₁⁻¹ i x₁⁻¹ = (update f₁ i x₁)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Inv (f i)] [DecidableEq I] (f₁ : (i : I) → f i) (i : I) (x₁ : f i)
Goal: Function.update f₁⁻¹ i x₁⁻¹ = (Function.update f₁ i x₁)⁻¹
-- Function.update_neg
@[to_additive]
theorem update_inv [∀ i, Inv (f i)] [DecidableEq I] (f₁ : ∀ i, f i) (i : I) (x₁ : f i) :
    update f₁⁻¹ i x₁⁻¹ = (update f₁ i x₁)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Neg (f i)] [DecidableEq I] (f₁ : (i : I) → f i) (i : I) (x₁ : f i)
Goal: Function.update (-f₁) i (-x₁) = -Function.update f₁ i x₁
-- Function.update_sub
@[to_additive]
theorem update_div [∀ i, Div (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (i : I) (x₁ : f i)
    (x₂ : f i) : update (f₁ / f₂) i (x₁ / x₂) = update f₁ i x₁ / update f₂ i x₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Sub (f i)] [DecidableEq I] (f₁ f₂ : (i : I) → f i) (i : I) (x₁ x₂ : f i)
Goal: Function.update (f₁ - f₂) i (x₁ - x₂) = Function.update f₁ i x₁ - Function.update f₂ i x₂
-- Function.update_div
@[to_additive]
theorem update_div [∀ i, Div (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (i : I) (x₁ : f i)
    (x₂ : f i) : update (f₁ / f₂) i (x₁ / x₂) = update f₁ i x₁ / update f₂ i x₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Div (f i)] [DecidableEq I] (f₁ f₂ : (i : I) → f i) (i : I) (x₁ x₂ : f i)
Goal: Function.update (f₁ / f₂) i (x₁ / x₂) = Function.update f₁ i x₁ / Function.update f₂ i x₂
-- Function.const_eq_one
@[to_additive (attr := simp)]
theorem const_eq_one : const ι a = 1 ↔ a = 1 
Arguments: {ι : Type u_1} {α : Type u_2} [One α] [Nonempty ι] {a : α}
Goal: Function.const ι a = 1 ↔ a = 1
-- Function.const_eq_zero
@[to_additive (attr := simp)]
theorem const_eq_one : const ι a = 1 ↔ a = 1 
Arguments: {ι : Type u_1} {α : Type u_2} [Zero α] [Nonempty ι] {a : α}
Goal: Function.const ι a = 0 ↔ a = 0
-- Function.const_ne_one
@[to_additive]
theorem const_ne_one : const ι a ≠ 1 ↔ a ≠ 1 
Arguments: {ι : Type u_1} {α : Type u_2} [One α] [Nonempty ι] {a : α}
Goal: Function.const ι a ≠ 1 ↔ a ≠ 1
-- Function.const_ne_zero
@[to_additive]
theorem const_ne_one : const ι a ≠ 1 ↔ a ≠ 1 
Arguments: {ι : Type u_1} {α : Type u_2} [Zero α] [Nonempty ι] {a : α}
Goal: Function.const ι a ≠ 0 ↔ a ≠ 0
-- Set.piecewise_add
@[to_additive]
theorem Set.piecewise_mul [∀ i, Mul (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)]
    (f₁ f₂ g₁ g₂ : ∀ i, f i) :
    s.piecewise (f₁ * f₂) (g₁ * g₂) = s.piecewise f₁ g₁ * s.piecewise f₂ g₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Add (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ f₂ g₁ g₂ : (i : I) → f i)
Goal: s.piecewise (f₁ + f₂) (g₁ + g₂) = s.piecewise f₁ g₁ + s.piecewise f₂ g₂
-- Set.piecewise_mul
@[to_additive]
theorem Set.piecewise_mul [∀ i, Mul (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)]
    (f₁ f₂ g₁ g₂ : ∀ i, f i) :
    s.piecewise (f₁ * f₂) (g₁ * g₂) = s.piecewise f₁ g₁ * s.piecewise f₂ g₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Mul (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ f₂ g₁ g₂ : (i : I) → f i)
Goal: s.piecewise (f₁ * f₂) (g₁ * g₂) = s.piecewise f₁ g₁ * s.piecewise f₂ g₂
-- Set.piecewise_inv
@[to_additive]
theorem Set.piecewise_inv [∀ i, Inv (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)] (f₁ g₁ : ∀ i, f i) :
    s.piecewise f₁⁻¹ g₁⁻¹ = (s.piecewise f₁ g₁)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Inv (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ g₁ : (i : I) → f i)
Goal: s.piecewise f₁⁻¹ g₁⁻¹ = (s.piecewise f₁ g₁)⁻¹
-- Set.piecewise_neg
@[to_additive]
theorem Set.piecewise_inv [∀ i, Inv (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)] (f₁ g₁ : ∀ i, f i) :
    s.piecewise f₁⁻¹ g₁⁻¹ = (s.piecewise f₁ g₁)⁻¹ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Neg (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ g₁ : (i : I) → f i)
Goal: s.piecewise (-f₁) (-g₁) = -s.piecewise f₁ g₁
-- Set.piecewise_sub
@[to_additive]
theorem Set.piecewise_div [∀ i, Div (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)]
    (f₁ f₂ g₁ g₂ : ∀ i, f i) :
    s.piecewise (f₁ / f₂) (g₁ / g₂) = s.piecewise f₁ g₁ / s.piecewise f₂ g₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Sub (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ f₂ g₁ g₂ : (i : I) → f i)
Goal: s.piecewise (f₁ - f₂) (g₁ - g₂) = s.piecewise f₁ g₁ - s.piecewise f₂ g₂
-- Set.piecewise_div
@[to_additive]
theorem Set.piecewise_div [∀ i, Div (f i)] (s : Set I) [∀ i, Decidable (i ∈ s)]
    (f₁ f₂ g₁ g₂ : ∀ i, f i) :
    s.piecewise (f₁ / f₂) (g₁ / g₂) = s.piecewise f₁ g₁ / s.piecewise f₂ g₂ 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Div (f i)] (s : Set I) [(i : I) → Decidable (i ∈ s)] (f₁ f₂ g₁ g₂ : (i : I) → f i)
Goal: s.piecewise (f₁ / f₂) (g₁ / g₂) = s.piecewise f₁ g₁ / s.piecewise f₂ g₂
-- Function.ExtendByOne.hom_apply
@[to_additive (attr := simps) Function.ExtendByZero.hom "`Function.extend s f 0` as a bundled hom."]
noncomputable def Function.ExtendByOne.hom [MulOneClass R] :
    (ι → R) →* η → R 
Arguments: {ι : Type u_1} {η : Type v} (R : Type w) (s : ι → η) [MulOneClass R] (f : ι → R)
Goal: ∀ (a : η), (Function.ExtendByOne.hom R s) f a = Function.extend s f 1 a
-- Function.ExtendByZero.hom_apply
@[to_additive (attr := simps) Function.ExtendByZero.hom "`Function.extend s f 0` as a bundled hom."]
noncomputable def Function.ExtendByOne.hom [MulOneClass R] :
    (ι → R) →* η → R 
Arguments: {ι : Type u_1} {η : Type v} (R : Type w) (s : ι → η) [AddZeroClass R] (f : ι → R)
Goal: ∀ (a : η), (Function.ExtendByZero.hom R s) f a = Function.extend s f 0 a
-- Pi.single_mono
@[to_additive]
theorem mulSingle_mono : Monotone (Pi.mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → Preorder (f i)] [(i : I) → Zero (f i)]
Goal: Monotone (Pi.single i)
-- Pi.mulSingle_mono
@[to_additive]
theorem mulSingle_mono : Monotone (Pi.mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → Preorder (f i)] [(i : I) → One (f i)]
Goal: Monotone (Pi.mulSingle i)
-- Pi.mulSingle_strictMono
@[to_additive]
theorem mulSingle_strictMono : StrictMono (Pi.mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → Preorder (f i)] [(i : I) → One (f i)]
Goal: StrictMono (Pi.mulSingle i)
-- Pi.single_strictMono
@[to_additive]
theorem mulSingle_strictMono : StrictMono (Pi.mulSingle i : f i → ∀ i, f i) 
Arguments: {I : Type u} {f : I → Type v} (i : I) [DecidableEq I] [(i : I) → Preorder (f i)] [(i : I) → Zero (f i)]
Goal: StrictMono (Pi.single i)
-- Sigma.curry_one
@[to_additive (attr := simp)]
theorem curry_one [∀ a b, One (γ a b)] : Sigma.curry (1 : (i : Σ a, β a) → γ i.1 i.2) = 1 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → One (γ a b)]
Goal: Sigma.curry 1 = 1
-- Sigma.curry_zero
@[to_additive (attr := simp)]
theorem curry_one [∀ a b, One (γ a b)] : Sigma.curry (1 : (i : Σ a, β a) → γ i.1 i.2) = 1 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Zero (γ a b)]
Goal: Sigma.curry 0 = 0
-- Sigma.uncurry_zero
@[to_additive (attr := simp)]
theorem uncurry_one [∀ a b, One (γ a b)] : Sigma.uncurry (1 : ∀ a b, γ a b) = 1 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Zero (γ a b)]
Goal: Sigma.uncurry 0 = 0
-- Sigma.uncurry_one
@[to_additive (attr := simp)]
theorem uncurry_one [∀ a b, One (γ a b)] : Sigma.uncurry (1 : ∀ a b, γ a b) = 1 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → One (γ a b)]
Goal: Sigma.uncurry 1 = 1
-- Sigma.curry_add
@[to_additive (attr := simp)]
theorem curry_mul [∀ a b, Mul (γ a b)] (x y : (i : Σ a, β a) → γ i.1 i.2) :
    Sigma.curry (x * y) = Sigma.curry x * Sigma.curry y 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Add (γ a b)] (x y : (i : (a : α) × β a) → γ i.fst i.snd)
Goal: Sigma.curry (x + y) = Sigma.curry x + Sigma.curry y
-- Sigma.curry_mul
@[to_additive (attr := simp)]
theorem curry_mul [∀ a b, Mul (γ a b)] (x y : (i : Σ a, β a) → γ i.1 i.2) :
    Sigma.curry (x * y) = Sigma.curry x * Sigma.curry y 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Mul (γ a b)] (x y : (i : (a : α) × β a) → γ i.fst i.snd)
Goal: Sigma.curry (x * y) = Sigma.curry x * Sigma.curry y
-- Sigma.uncurry_add
@[to_additive (attr := simp)]
theorem uncurry_mul [∀ a b, Mul (γ a b)] (x y : ∀ a b, γ a b) :
    Sigma.uncurry (x * y) = Sigma.uncurry x * Sigma.uncurry y 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Add (γ a b)] (x y : (a : α) → (b : β a) → γ a b)
Goal: Sigma.uncurry (x + y) = Sigma.uncurry x + Sigma.uncurry y
-- Sigma.uncurry_mul
@[to_additive (attr := simp)]
theorem uncurry_mul [∀ a b, Mul (γ a b)] (x y : ∀ a b, γ a b) :
    Sigma.uncurry (x * y) = Sigma.uncurry x * Sigma.uncurry y 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Mul (γ a b)] (x y : (a : α) → (b : β a) → γ a b)
Goal: Sigma.uncurry (x * y) = Sigma.uncurry x * Sigma.uncurry y
-- Sigma.curry_neg
@[to_additive (attr := simp)]
theorem curry_inv [∀ a b, Inv (γ a b)] (x : (i : Σ a, β a) → γ i.1 i.2) :
    Sigma.curry (x⁻¹) = (Sigma.curry x)⁻¹ 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Neg (γ a b)] (x : (i : (a : α) × β a) → γ i.fst i.snd)
Goal: Sigma.curry (-x) = -Sigma.curry x
-- Sigma.curry_inv
@[to_additive (attr := simp)]
theorem curry_inv [∀ a b, Inv (γ a b)] (x : (i : Σ a, β a) → γ i.1 i.2) :
    Sigma.curry (x⁻¹) = (Sigma.curry x)⁻¹ 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Inv (γ a b)] (x : (i : (a : α) × β a) → γ i.fst i.snd)
Goal: Sigma.curry x⁻¹ = (Sigma.curry x)⁻¹
-- Sigma.uncurry_neg
@[to_additive (attr := simp)]
theorem uncurry_inv [∀ a b, Inv (γ a b)] (x : ∀ a b, γ a b) :
    Sigma.uncurry (x⁻¹) = (Sigma.uncurry x)⁻¹ 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Neg (γ a b)] (x : (a : α) → (b : β a) → γ a b)
Goal: Sigma.uncurry (-x) = -Sigma.uncurry x
-- Sigma.uncurry_inv
@[to_additive (attr := simp)]
theorem uncurry_inv [∀ a b, Inv (γ a b)] (x : ∀ a b, γ a b) :
    Sigma.uncurry (x⁻¹) = (Sigma.uncurry x)⁻¹ 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [(a : α) → (b : β a) → Inv (γ a b)] (x : (a : α) → (b : β a) → γ a b)
Goal: Sigma.uncurry x⁻¹ = (Sigma.uncurry x)⁻¹
-- Sigma.curry_mulSingle
@[to_additive (attr := simp)]
theorem curry_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
    (i : Σ a, β a) (x : γ i.1 i.2) :
    Sigma.curry (Pi.mulSingle i x) = Pi.mulSingle i.1 (Pi.mulSingle i.2 x) 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [DecidableEq α] [(a : α) → DecidableEq (β a)] [(a : α) → (b : β a) → One (γ a b)] (i : (a : α) × β a) (x : γ i.fst i.snd)
Goal: Sigma.curry (Pi.mulSingle i x) = Pi.mulSingle i.fst (Pi.mulSingle i.snd x)
-- Sigma.curry_single
@[to_additive (attr := simp)]
theorem curry_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
    (i : Σ a, β a) (x : γ i.1 i.2) :
    Sigma.curry (Pi.mulSingle i x) = Pi.mulSingle i.1 (Pi.mulSingle i.2 x) 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [DecidableEq α] [(a : α) → DecidableEq (β a)] [(a : α) → (b : β a) → Zero (γ a b)] (i : (a : α) × β a) (x : γ i.fst i.snd)
Goal: Sigma.curry (Pi.single i x) = Pi.single i.fst (Pi.single i.snd x)
-- Sigma.uncurry_mulSingle_mulSingle
@[to_additive (attr := simp)]
theorem uncurry_mulSingle_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
    (a : α) (b : β a) (x : γ a b) :
    Sigma.uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle (Sigma.mk a b) x 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [DecidableEq α] [(a : α) → DecidableEq (β a)] [(a : α) → (b : β a) → One (γ a b)] (a : α) (b : β a) (x : γ a b)
Goal: Sigma.uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x
-- Sigma.uncurry_single_single
@[to_additive (attr := simp)]
theorem uncurry_mulSingle_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
    (a : α) (b : β a) (x : γ a b) :
    Sigma.uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle (Sigma.mk a b) x 
Arguments: {α : Type u_3} {β : α → Type u_4} {γ : (a : α) → β a → Type u_5} [DecidableEq α] [(a : α) → DecidableEq (β a)] [(a : α) → (b : β a) → Zero (γ a b)] (a : α) (b : β a) (x : γ a b)
Goal: Sigma.uncurry (Pi.single a (Pi.single b x)) = Pi.single ⟨a, b⟩ x
-- Set.piecewise_eq_indicator
@[to_additive (attr := simp)]
theorem piecewise_eq_mulIndicator [DecidablePred (· ∈ s)] : s.piecewise f 1 = s.mulIndicator f 
Arguments: {α : Type u_1} {M : Type u_4} [Zero M] {s : Set α} {f : α → M} [DecidablePred fun x => x ∈ s]
Goal: s.piecewise f 0 = s.indicator f
-- Set.piecewise_eq_mulIndicator
@[to_additive (attr := simp)]
theorem piecewise_eq_mulIndicator [DecidablePred (· ∈ s)] : s.piecewise f 1 = s.mulIndicator f 
Arguments: {α : Type u_1} {M : Type u_4} [One M] {s : Set α} {f : α → M} [DecidablePred fun x => x ∈ s]
Goal: s.piecewise f 1 = s.mulIndicator f
-- Set.mulIndicator_apply
@[to_additive]
theorem mulIndicator_apply (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)] :
    mulIndicator s f a = if a ∈ s then f a else 1 
Arguments: {α : Type u_1} {M : Type u_4} [One M] (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)]
Goal: s.mulIndicator f a = if a ∈ s then f a else 1
-- Set.indicator_apply
@[to_additive]
theorem mulIndicator_apply (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)] :
    mulIndicator s f a = if a ∈ s then f a else 1 
Arguments: {α : Type u_1} {M : Type u_4} [Zero M] (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)]
Goal: s.indicator f a = if a ∈ s then f a else 0
-- Set.indicator_of_mem
@[to_additive (attr := simp)]
theorem mulIndicator_of_mem (h : a ∈ s) (f : α → M) : mulIndicator s f a = f a 
Arguments: {α : Type u_1} {M : Type u_4} [Zero M] {s : Set α} {a : α} (h : a ∈ s) (f : α → M)
Goal: s.indicator f a = f a
-- Set.mulIndicator_of_mem
@[to_additive (attr := simp)]
theorem mulIndicator_of_mem (h : a ∈ s) (f : α → M) : mulIndicator s f a = f a 
Arguments: {α : Type u_1} {M : Type u_4} [One M] {s : Set α} {a : α} (h : a ∈ s) (f : α → M)
Goal: s.mulIndicator f a = f a
-- Set.indicator_of_not_mem
@[to_additive (attr := simp)]
theorem mulIndicator_of_not_mem (h : a ∉ s) (f : α → M) : mulIndicator s f a = 1 
Arguments: {α : Type u_1} {M : Type u_4} [Zero M] {s : Set α} {a : α} (h : a ∉ s) (f : α → M)
Goal: s.indicator f a = 0