File: Mathlib/Algebra/Group/Pi/Basic.lean

full_name: Pi.instOne
code: @[to_additive]
instance instOne [∀ i, One <| f i] : One (∀ i : I, f i) 
goal: One ((i : I) → f i)

full_name: Pi.instZero
code: @[to_additive]
instance instOne [∀ i, One <| f i] : One (∀ i : I, f i) 
goal: Zero ((i : I) → f i)

full_name: Pi.zero_apply
code: @[to_additive (attr := simp, nolint simpNF)]
theorem one_apply [∀ i, One <| f i] : (1 : ∀ i, f i) i = 1 
goal: 0 i = 0

full_name: Pi.one_apply
code: @[to_additive (attr := simp, nolint simpNF)]
theorem one_apply [∀ i, One <| f i] : (1 : ∀ i, f i) i = 1 
goal: 1 i = 1

full_name: Pi.one_def
code: @[to_additive]
theorem one_def [∀ i, One <| f i] : (1 : ∀ i, f i) = fun _ => 1 
goal: 1 = fun x => 1

full_name: Pi.zero_def
code: @[to_additive]
theorem one_def [∀ i, One <| f i] : (1 : ∀ i, f i) = fun _ => 1 
goal: 0 = fun x => 0

full_name: Function.const_zero
code: @[to_additive (attr := simp)] lemma _root_.Function.const_one [One β] : const α (1 : β) = 1 
goal: Function.const α 0 = 0

full_name: Function.const_one
code: @[to_additive (attr := simp)] lemma _root_.Function.const_one [One β] : const α (1 : β) = 1 
goal: Function.const α 1 = 1

full_name: Pi.one_comp
code: @[to_additive (attr := simp)]
theorem one_comp [One γ] (x : α → β) : (1 : β → γ) ∘ x = 1 
goal: 1 ∘ x = 1

full_name: Pi.zero_comp
code: @[to_additive (attr := simp)]
theorem one_comp [One γ] (x : α → β) : (1 : β → γ) ∘ x = 1 
goal: 0 ∘ x = 0

full_name: Pi.comp_zero
code: @[to_additive (attr := simp)]
theorem comp_one [One β] (x : β → γ) : x ∘ (1 : α → β) = const α (x 1) 
goal: x ∘ 0 = Function.const α (x 0)

full_name: Pi.comp_one
code: @[to_additive (attr := simp)]
theorem comp_one [One β] (x : β → γ) : x ∘ (1 : α → β) = const α (x 1) 
goal: x ∘ 1 = Function.const α (x 1)

full_name: Pi.instAdd
code: @[to_additive]
instance instMul [∀ i, Mul <| f i] : Mul (∀ i : I, f i) 
goal: Add ((i : I) → f i)

full_name: Pi.instMul
code: @[to_additive]
instance instMul [∀ i, Mul <| f i] : Mul (∀ i : I, f i) 
goal: Mul ((i : I) → f i)

full_name: Pi.add_apply
code: @[to_additive (attr := simp)]
theorem mul_apply [∀ i, Mul <| f i] : (x * y) i = x i * y i 
goal: (x + y) i = x i + y i

full_name: Pi.mul_apply
code: @[to_additive (attr := simp)]
theorem mul_apply [∀ i, Mul <| f i] : (x * y) i = x i * y i 
goal: (x * y) i = x i * y i

full_name: Pi.mul_def
code: @[to_additive]
theorem mul_def [∀ i, Mul <| f i] : x * y = fun i => x i * y i 
goal: x * y = fun i => x i * y i

full_name: Pi.add_def
code: @[to_additive]
theorem mul_def [∀ i, Mul <| f i] : x * y = fun i => x i * y i 
goal: x + y = fun i => x i + y i

full_name: Function.const_mul
code: @[to_additive (attr := simp)]
lemma _root_.Function.const_mul [Mul β] (a b : β) : const α a * const α b = const α (a * b) 
goal: Function.const α a * Function.const α b = Function.const α (a * b)

full_name: Function.const_add
code: @[to_additive (attr := simp)]
lemma _root_.Function.const_mul [Mul β] (a b : β) : const α a * const α b = const α (a * b) 
goal: Function.const α a + Function.const α b = Function.const α (a + b)

full_name: Pi.mul_comp
code: @[to_additive]
theorem mul_comp [Mul γ] (x y : β → γ) (z : α → β) : (x * y) ∘ z = x ∘ z * y ∘ z 
goal: (x * y) ∘ z = x ∘ z * y ∘ z

full_name: Pi.add_comp
code: @[to_additive]
theorem mul_comp [Mul γ] (x y : β → γ) (z : α → β) : (x * y) ∘ z = x ∘ z * y ∘ z 
goal: (x + y) ∘ z = x ∘ z + y ∘ z

full_name: Pi.instVAdd
code: @[to_additive]
instance instSMul [∀ i, SMul α <| f i] : SMul α (∀ i : I, f i) 
goal: VAdd α ((i : I) → f i)

full_name: Pi.instSMul
code: @[to_additive]
instance instSMul [∀ i, SMul α <| f i] : SMul α (∀ i : I, f i) 
goal: SMul α ((i : I) → f i)

full_name: Pi.instPow
code: @[to_additive existing instSMul]
instance instPow [∀ i, Pow (f i) β] : Pow (∀ i, f i) β 
goal: Pow ((i : I) → f i) β

full_name: Pi.smul_apply
code: @[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 
goal: (b • x) i = b • x i

full_name: Pi.vadd_apply
code: @[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 
goal: (b +ᵥ x) i = b +ᵥ x i

full_name: Pi.pow_apply
code: @[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 
goal: (x ^ b) i = x i ^ b

full_name: Pi.smul_def
code: @[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 
goal: b • x = fun i => b • x i

full_name: Pi.pow_def
code: @[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 
goal: x ^ b = fun i => x i ^ b

full_name: Pi.vadd_def
code: @[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 
goal: b +ᵥ x = fun i => b +ᵥ x i

full_name: Function.const_pow
code: @[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) 
goal: Function.const I a ^ b = Function.const I (a ^ b)

full_name: Function.smul_const
code: @[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) 
goal: b • Function.const I a = Function.const I (b • a)

full_name: Function.vadd_const
code: @[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) 
goal: b +ᵥ Function.const I a = Function.const I (b +ᵥ a)

full_name: Pi.pow_comp
code: @[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
goal: (x ^ a) ∘ y = x ∘ y ^ a

full_name: Pi.vadd_comp
code: @[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
goal: (a +ᵥ x) ∘ y = a +ᵥ x ∘ y

full_name: Pi.smul_comp
code: @[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a 
goal: (a • x) ∘ y = a • x ∘ y

full_name: Pi.instInv
code: @[to_additive]
instance instInv [∀ i, Inv <| f i] : Inv (∀ i : I, f i) 
goal: Inv ((i : I) → f i)

full_name: Pi.instNeg
code: @[to_additive]
instance instInv [∀ i, Inv <| f i] : Inv (∀ i : I, f i) 
goal: Neg ((i : I) → f i)

full_name: Pi.neg_apply
code: @[to_additive (attr := simp)]
theorem inv_apply [∀ i, Inv <| f i] : x⁻¹ i = (x i)⁻¹ 
goal: (-x) i = -x i

full_name: Pi.inv_apply
code: @[to_additive (attr := simp)]
theorem inv_apply [∀ i, Inv <| f i] : x⁻¹ i = (x i)⁻¹ 
goal: x⁻¹ i = (x i)⁻¹

full_name: Pi.inv_def
code: @[to_additive]
theorem inv_def [∀ i, Inv <| f i] : x⁻¹ = fun i => (x i)⁻¹ 
goal: x⁻¹ = fun i => (x i)⁻¹

full_name: Pi.neg_def
code: @[to_additive]
theorem inv_def [∀ i, Inv <| f i] : x⁻¹ = fun i => (x i)⁻¹ 
goal: -x = fun i => -x i

full_name: Function.const_neg
code: @[to_additive]
lemma _root_.Function.const_inv [Inv β] (a : β) : (const α a)⁻¹ = const α a⁻¹ 
goal: -Function.const α a = Function.const α (-a)

full_name: Function.const_inv
code: @[to_additive]
lemma _root_.Function.const_inv [Inv β] (a : β) : (const α a)⁻¹ = const α a⁻¹ 
goal: (Function.const α a)⁻¹ = Function.const α a⁻¹

full_name: Pi.neg_comp
code: @[to_additive]
theorem inv_comp [Inv γ] (x : β → γ) (y : α → β) : x⁻¹ ∘ y = (x ∘ y)⁻¹ 
goal: (-x) ∘ y = -x ∘ y

full_name: Pi.inv_comp
code: @[to_additive]
theorem inv_comp [Inv γ] (x : β → γ) (y : α → β) : x⁻¹ ∘ y = (x ∘ y)⁻¹ 
goal: x⁻¹ ∘ y = (x ∘ y)⁻¹

full_name: Pi.instSub
code: @[to_additive]
instance instDiv [∀ i, Div <| f i] : Div (∀ i : I, f i) 
goal: Sub ((i : I) → f i)

full_name: Pi.instDiv
code: @[to_additive]
instance instDiv [∀ i, Div <| f i] : Div (∀ i : I, f i) 
goal: Div ((i : I) → f i)

full_name: Pi.sub_apply
code: @[to_additive (attr := simp)]
theorem div_apply [∀ i, Div <| f i] : (x / y) i = x i / y i 
goal: (x - y) i = x i - y i

full_name: Pi.div_apply
code: @[to_additive (attr := simp)]
theorem div_apply [∀ i, Div <| f i] : (x / y) i = x i / y i 
goal: (x / y) i = x i / y i

full_name: Pi.sub_def
code: @[to_additive]
theorem div_def [∀ i, Div <| f i] : x / y = fun i => x i / y i 
goal: x - y = fun i => x i - y i

full_name: Pi.div_def
code: @[to_additive]
theorem div_def [∀ i, Div <| f i] : x / y = fun i => x i / y i 
goal: x / y = fun i => x i / y i

full_name: Pi.div_comp
code: @[to_additive]
theorem div_comp [Div γ] (x y : β → γ) (z : α → β) : (x / y) ∘ z = x ∘ z / y ∘ z 
goal: (x / y) ∘ z = x ∘ z / y ∘ z

full_name: Pi.sub_comp
code: @[to_additive]
theorem div_comp [Div γ] (x y : β → γ) (z : α → β) : (x / y) ∘ z = x ∘ z / y ∘ z 
goal: (x - y) ∘ z = x ∘ z - y ∘ z

full_name: Function.const_sub
code: @[to_additive (attr := simp)]
lemma _root_.Function.const_div [Div β] (a b : β) : const α a / const α b = const α (a / b) 
goal: Function.const α a - Function.const α b = Function.const α (a - b)

full_name: Function.const_div
code: @[to_additive (attr := simp)]
lemma _root_.Function.const_div [Div β] (a b : β) : const α a / const α b = const α (a / b) 
goal: Function.const α a / Function.const α b = Function.const α (a / b)

full_name: Pi.addSemigroup
code: @[to_additive]
instance semigroup [∀ i, Semigroup (f i)] : Semigroup (∀ i, f i) 
goal: AddSemigroup ((i : I) → f i)

full_name: Pi.semigroup
code: @[to_additive]
instance semigroup [∀ i, Semigroup (f i)] : Semigroup (∀ i, f i) 
goal: Semigroup ((i : I) → f i)

full_name: Pi.addCommSemigroup
code: @[to_additive]
instance commSemigroup [∀ i, CommSemigroup (f i)] : CommSemigroup (∀ i, f i) 
goal: AddCommSemigroup ((i : I) → f i)

full_name: Pi.commSemigroup
code: @[to_additive]
instance commSemigroup [∀ i, CommSemigroup (f i)] : CommSemigroup (∀ i, f i) 
goal: CommSemigroup ((i : I) → f i)

full_name: Pi.mulOneClass
code: @[to_additive]
instance mulOneClass [∀ i, MulOneClass (f i)] : MulOneClass (∀ i, f i) 
goal: MulOneClass ((i : I) → f i)

full_name: Pi.addZeroClass
code: @[to_additive]
instance mulOneClass [∀ i, MulOneClass (f i)] : MulOneClass (∀ i, f i) 
goal: AddZeroClass ((i : I) → f i)

full_name: Pi.invOneClass
code: @[to_additive]
instance invOneClass [∀ i, InvOneClass (f i)] : InvOneClass (∀ i, f i) 
goal: InvOneClass ((i : I) → f i)

full_name: Pi.negZeroClass
code: @[to_additive]
instance invOneClass [∀ i, InvOneClass (f i)] : InvOneClass (∀ i, f i) 
goal: NegZeroClass ((i : I) → f i)

full_name: Pi.addMonoid
code: @[to_additive]
instance monoid [∀ i, Monoid (f i)] : Monoid (∀ i, f i) 
goal: AddMonoid ((i : I) → f i)

full_name: Pi.monoid
code: @[to_additive]
instance monoid [∀ i, Monoid (f i)] : Monoid (∀ i, f i) 
goal: Monoid ((i : I) → f i)

full_name: Pi.addCommMonoid
code: @[to_additive]
instance commMonoid [∀ i, CommMonoid (f i)] : CommMonoid (∀ i, f i) 
goal: AddCommMonoid ((i : I) → f i)

full_name: Pi.commMonoid
code: @[to_additive]
instance commMonoid [∀ i, CommMonoid (f i)] : CommMonoid (∀ i, f i) 
goal: CommMonoid ((i : I) → f i)

full_name: Pi.divInvMonoid
code: @[to_additive Pi.subNegMonoid]
instance divInvMonoid [∀ i, DivInvMonoid (f i)] : DivInvMonoid (∀ i, f i) 
goal: DivInvMonoid ((i : I) → f i)

full_name: Pi.subNegMonoid
code: @[to_additive Pi.subNegMonoid]
instance divInvMonoid [∀ i, DivInvMonoid (f i)] : DivInvMonoid (∀ i, f i) 
goal: SubNegMonoid ((i : I) → f i)

full_name: Pi.divInvOneMonoid
code: @[to_additive Pi.subNegZeroMonoid]
instance divInvOneMonoid [∀ i, DivInvOneMonoid (f i)] : DivInvOneMonoid (∀ i, f i) 
goal: DivInvOneMonoid ((i : I) → f i)

full_name: Pi.subNegZeroMonoid
code: @[to_additive Pi.subNegZeroMonoid]
instance divInvOneMonoid [∀ i, DivInvOneMonoid (f i)] : DivInvOneMonoid (∀ i, f i) 
goal: SubNegZeroMonoid ((i : I) → f i)

full_name: Pi.involutiveInv
code: @[to_additive]
instance involutiveInv [∀ i, InvolutiveInv (f i)] : InvolutiveInv (∀ i, f i) 
goal: InvolutiveInv ((i : I) → f i)

full_name: Pi.involutiveNeg
code: @[to_additive]
instance involutiveInv [∀ i, InvolutiveInv (f i)] : InvolutiveInv (∀ i, f i) 
goal: InvolutiveNeg ((i : I) → f i)

full_name: Pi.divisionMonoid
code: @[to_additive Pi.subtractionMonoid]
instance divisionMonoid [∀ i, DivisionMonoid (f i)] : DivisionMonoid (∀ i, f i) 
goal: DivisionMonoid ((i : I) → f i)

full_name: Pi.subtractionMonoid
code: @[to_additive Pi.subtractionMonoid]
instance divisionMonoid [∀ i, DivisionMonoid (f i)] : DivisionMonoid (∀ i, f i) 
goal: SubtractionMonoid ((i : I) → f i)

full_name: Pi.instSubtractionCommMonoid
code: @[to_additive instSubtractionCommMonoid]
instance divisionCommMonoid [∀ i, DivisionCommMonoid (f i)] : DivisionCommMonoid (∀ i, f i) 
goal: SubtractionCommMonoid ((i : I) → f i)

full_name: Pi.divisionCommMonoid
code: @[to_additive instSubtractionCommMonoid]
instance divisionCommMonoid [∀ i, DivisionCommMonoid (f i)] : DivisionCommMonoid (∀ i, f i) 
goal: DivisionCommMonoid ((i : I) → f i)

full_name: Pi.group
code: @[to_additive]
instance group [∀ i, Group (f i)] : Group (∀ i, f i) 
goal: Group ((i : I) → f i)

full_name: Pi.addGroup
code: @[to_additive]
instance group [∀ i, Group (f i)] : Group (∀ i, f i) 
goal: AddGroup ((i : I) → f i)

full_name: Pi.addCommGroup
code: @[to_additive]
instance commGroup [∀ i, CommGroup (f i)] : CommGroup (∀ i, f i) 
goal: AddCommGroup ((i : I) → f i)

full_name: Pi.commGroup
code: @[to_additive]
instance commGroup [∀ i, CommGroup (f i)] : CommGroup (∀ i, f i) 
goal: CommGroup ((i : I) → f i)

full_name: Pi.instIsAddLeftCancel
code: @[to_additive] instance instIsLeftCancelMul [∀ i, Mul (f i)] [∀ i, IsLeftCancelMul (f i)] :
    IsLeftCancelMul (∀ i, f i) 
goal: IsLeftCancelAdd ((i : I) → f i)

full_name: Pi.instIsLeftCancelMul
code: @[to_additive] instance instIsLeftCancelMul [∀ i, Mul (f i)] [∀ i, IsLeftCancelMul (f i)] :
    IsLeftCancelMul (∀ i, f i) 
goal: IsLeftCancelMul ((i : I) → f i)

full_name: Pi.instIsAddRightCancel
code: @[to_additive] instance instIsRightCancelMul [∀ i, Mul (f i)] [∀ i, IsRightCancelMul (f i)] :
    IsRightCancelMul (∀ i, f i) 
goal: IsRightCancelAdd ((i : I) → f i)

full_name: Pi.instIsRightCancelMul
code: @[to_additive] instance instIsRightCancelMul [∀ i, Mul (f i)] [∀ i, IsRightCancelMul (f i)] :
    IsRightCancelMul (∀ i, f i) 
goal: IsRightCancelMul ((i : I) → f i)

full_name: Pi.instIsAddCancel
code: @[to_additive] instance instIsCancelMul [∀ i, Mul (f i)] [∀ i, IsCancelMul (f i)] :
    IsCancelMul (∀ i, f i) 
goal: IsCancelAdd ((i : I) → f i)

full_name: Pi.instIsCancelMul
code: @[to_additive] instance instIsCancelMul [∀ i, Mul (f i)] [∀ i, IsCancelMul (f i)] :
    IsCancelMul (∀ i, f i) 
goal: IsCancelMul ((i : I) → f i)

full_name: Pi.addLeftCancelSemigroup
code: @[to_additive]
instance leftCancelSemigroup [∀ i, LeftCancelSemigroup (f i)] : LeftCancelSemigroup (∀ i, f i) 
goal: AddLeftCancelSemigroup ((i : I) → f i)

full_name: Pi.leftCancelSemigroup
code: @[to_additive]
instance leftCancelSemigroup [∀ i, LeftCancelSemigroup (f i)] : LeftCancelSemigroup (∀ i, f i) 
goal: LeftCancelSemigroup ((i : I) → f i)

full_name: Pi.addRightCancelSemigroup
code: @[to_additive]
instance rightCancelSemigroup [∀ i, RightCancelSemigroup (f i)] : RightCancelSemigroup (∀ i, f i) 
goal: AddRightCancelSemigroup ((i : I) → f i)

full_name: Pi.rightCancelSemigroup
code: @[to_additive]
instance rightCancelSemigroup [∀ i, RightCancelSemigroup (f i)] : RightCancelSemigroup (∀ i, f i) 
goal: RightCancelSemigroup ((i : I) → f i)

full_name: Pi.leftCancelMonoid
code: @[to_additive]
instance leftCancelMonoid [∀ i, LeftCancelMonoid (f i)] : LeftCancelMonoid (∀ i, f i) 
goal: LeftCancelMonoid ((i : I) → f i)

full_name: Pi.addLeftCancelMonoid
code: @[to_additive]
instance leftCancelMonoid [∀ i, LeftCancelMonoid (f i)] : LeftCancelMonoid (∀ i, f i) 
goal: AddLeftCancelMonoid ((i : I) → f i)

full_name: Pi.addRightCancelMonoid
code: @[to_additive]
instance rightCancelMonoid [∀ i, RightCancelMonoid (f i)] : RightCancelMonoid (∀ i, f i) 
goal: AddRightCancelMonoid ((i : I) → f i)

full_name: Pi.rightCancelMonoid
code: @[to_additive]
instance rightCancelMonoid [∀ i, RightCancelMonoid (f i)] : RightCancelMonoid (∀ i, f i) 
goal: RightCancelMonoid ((i : I) → f i)

full_name: Pi.addCancelMonoid
code: @[to_additive]
instance cancelMonoid [∀ i, CancelMonoid (f i)] : CancelMonoid (∀ i, f i) 
goal: AddCancelMonoid ((i : I) → f i)

full_name: Pi.cancelMonoid
code: @[to_additive]
instance cancelMonoid [∀ i, CancelMonoid (f i)] : CancelMonoid (∀ i, f i) 
goal: CancelMonoid ((i : I) → f i)

full_name: Pi.addCancelCommMonoid
code: @[to_additive]
instance cancelCommMonoid [∀ i, CancelCommMonoid (f i)] : CancelCommMonoid (∀ i, f i) 
goal: AddCancelCommMonoid ((i : I) → f i)

full_name: Pi.cancelCommMonoid
code: @[to_additive]
instance cancelCommMonoid [∀ i, CancelCommMonoid (f i)] : CancelCommMonoid (∀ i, f i) 
goal: CancelCommMonoid ((i : I) → f i)

full_name: Pi.mulSingle
code: /-- The function supported at `i`, with value `x` there, and `1` elsewhere. -/
@[to_additive "The function supported at `i`, with value `x` there, and `0` elsewhere."]
def mulSingle (i : I) (x : f i) : ∀ (j : I), f j 
goal: f j

full_name: Pi.single
code: /-- The function supported at `i`, with value `x` there, and `1` elsewhere. -/
@[to_additive "The function supported at `i`, with value `x` there, and `0` elsewhere."]
def mulSingle (i : I) (x : f i) : ∀ (j : I), f j 
goal: f j

full_name: Pi.single_eq_same
code: @[to_additive (attr := simp)]
theorem mulSingle_eq_same (i : I) (x : f i) : mulSingle i x i = x 
goal: Pi.single i x i = x

full_name: Pi.mulSingle_eq_same
code: @[to_additive (attr := simp)]
theorem mulSingle_eq_same (i : I) (x : f i) : mulSingle i x i = x 
goal: Pi.mulSingle i x i = x

full_name: Pi.mulSingle_eq_of_ne
code: @[to_additive (attr := simp)]
theorem mulSingle_eq_of_ne {i i' : I} (h : i' ≠ i) (x : f i) : mulSingle i x i' = 1 
goal: Pi.mulSingle i x i' = 1

full_name: Pi.single_eq_of_ne
code: @[to_additive (attr := simp)]
theorem mulSingle_eq_of_ne {i i' : I} (h : i' ≠ i) (x : f i) : mulSingle i x i' = 1 
goal: Pi.single i x i' = 0

full_name: Pi.single_eq_of_ne'
code: /-- Abbreviation for `mulSingle_eq_of_ne h.symm`, for ease of use by `simp`. -/
@[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 
goal: Pi.single i x i' = 0

full_name: Pi.mulSingle_eq_of_ne'
code: /-- Abbreviation for `mulSingle_eq_of_ne h.symm`, for ease of use by `simp`. -/
@[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 
goal: Pi.mulSingle i x i' = 1

full_name: Pi.single_zero
code: @[to_additive (attr := simp)]
theorem mulSingle_one (i : I) : mulSingle i (1 : f i) = 1 
goal: Pi.single i 0 = 0

full_name: Pi.mulSingle_one
code: @[to_additive (attr := simp)]
theorem mulSingle_one (i : I) : mulSingle i (1 : f i) = 1 
goal: Pi.mulSingle i 1 = 1

full_name: Pi.mulSingle_apply
code: /-- On non-dependent functions, `Pi.mulSingle` can be expressed as an `ite` -/
@[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 
goal: Pi.mulSingle i x i' = if i' = i then x else 1

full_name: Pi.single_apply
code: /-- On non-dependent functions, `Pi.mulSingle` can be expressed as an `ite` -/
@[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 
goal: Pi.single i x i' = if i' = i then x else 0

full_name: Pi.single_comm
code: /-- On non-dependent functions, `Pi.mulSingle` is symmetric in the two indices. -/
@[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 
goal: Pi.single i x i' = Pi.single i' x i

full_name: Pi.mulSingle_comm
code: /-- On non-dependent functions, `Pi.mulSingle` is symmetric in the two indices. -/
@[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 
goal: Pi.mulSingle i x i' = Pi.mulSingle i' x i

full_name: Pi.apply_mulSingle
code: @[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 
goal: f' j (Pi.mulSingle i x j) = Pi.mulSingle i (f' i x) j

full_name: Pi.apply_single
code: @[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 
goal: f' j (Pi.single i x j) = Pi.single i (f' i x) j

full_name: Pi.apply_single₂
code: @[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 
goal: f' j (Pi.single i x j) (Pi.single i y j) = Pi.single i (f' i x y) j

full_name: Pi.apply_mulSingle₂
code: @[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 
goal: f' j (Pi.mulSingle i x j) (Pi.mulSingle i y j) = Pi.mulSingle i (f' i x y) j

full_name: Pi.single_op
code: @[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) 
goal: Pi.single i (op i x) = fun j => op j (Pi.single i x j)

full_name: Pi.mulSingle_op
code: @[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) 
goal: Pi.mulSingle i (op i x) = fun j => op j (Pi.mulSingle i x j)

full_name: Pi.mulSingle_op₂
code: @[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) 
goal: Pi.mulSingle i (op i x₁ x₂) = fun j => op j (Pi.mulSingle i x₁ j) (Pi.mulSingle i x₂ j)

full_name: Pi.single_op₂
code: @[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) 
goal: Pi.single i (op i x₁ x₂) = fun j => op j (Pi.single i x₁ j) (Pi.single i x₂ j)

full_name: Pi.mulSingle_injective
code: @[to_additive]
theorem mulSingle_injective (i : I) : Function.Injective (mulSingle i : f i → ∀ i, f i) 
goal: Function.Injective (Pi.mulSingle i)

full_name: Pi.single_injective
code: @[to_additive]
theorem mulSingle_injective (i : I) : Function.Injective (mulSingle i : f i → ∀ i, f i) 
goal: Function.Injective (Pi.single i)

full_name: Pi.mulSingle_inj
code: @[to_additive (attr := simp)]
theorem mulSingle_inj (i : I) {x y : f i} : mulSingle i x = mulSingle i y ↔ x = y 
goal: Pi.mulSingle i x = Pi.mulSingle i y ↔ x = y

full_name: Pi.single_inj
code: @[to_additive (attr := simp)]
theorem mulSingle_inj (i : I) {x y : f i} : mulSingle i x = mulSingle i y ↔ x = y 
goal: Pi.single i x = Pi.single i y ↔ x = y

full_name: Pi.prod
code: /-- The mapping into a product type built from maps into each component. -/
@[simp]
protected def prod (f' : ∀ i, f i) (g' : ∀ i, g i) (i : I) : f i × g i 
goal: f i × g i

full_name: Pi.prod_fst_snd
code: theorem prod_fst_snd : Pi.prod (Prod.fst : α × β → α) (Prod.snd : α × β → β) = id 
goal: Pi.prod Prod.fst Prod.snd = id

full_name: Pi.prod_snd_fst
code: theorem prod_snd_fst : Pi.prod (Prod.snd : α × β → β) (Prod.fst : α × β → α) = Prod.swap 
goal: Pi.prod Prod.snd Prod.fst = Prod.swap

full_name: Function.extend_zero
code: @[to_additive]
theorem extend_one [One γ] (f : α → β) : Function.extend f (1 : α → γ) (1 : β → γ) = 1 
goal: Function.extend f 0 0 = 0

full_name: Function.extend_one
code: @[to_additive]
theorem extend_one [One γ] (f : α → β) : Function.extend f (1 : α → γ) (1 : β → γ) = 1 
goal: Function.extend f 1 1 = 1

full_name: Function.extend_mul
code: @[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₂ 
goal: Function.extend f (g₁ * g₂) (e₁ * e₂) = Function.extend f g₁ e₁ * Function.extend f g₂ e₂

full_name: Function.extend_add
code: @[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₂ 
goal: Function.extend f (g₁ + g₂) (e₁ + e₂) = Function.extend f g₁ e₁ + Function.extend f g₂ e₂

full_name: Function.extend_inv
code: @[to_additive]
theorem extend_inv [Inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
    Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹ 
goal: Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹

full_name: Function.extend_neg
code: @[to_additive]
theorem extend_inv [Inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
    Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹ 
goal: Function.extend f (-g) (-e) = -Function.extend f g e

full_name: Function.extend_sub
code: @[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₂ 
goal: Function.extend f (g₁ - g₂) (e₁ - e₂) = Function.extend f g₁ e₁ - Function.extend f g₂ e₂

full_name: Function.extend_div
code: @[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₂ 
goal: Function.extend f (g₁ / g₂) (e₁ / e₂) = Function.extend f g₁ e₁ / Function.extend f g₂ e₂

full_name: Function.surjective_pi_map
code: 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) 
goal: Function.Surjective fun x i => F i (x i)

full_name: Function.injective_pi_map
code: 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) 
goal: Function.Injective fun x i => F i (x i)

full_name: Function.bijective_pi_map
code: 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) 
goal: Function.Bijective fun x i => F i (x i)

full_name: Function.comp_eq_const_iff
code: lemma comp_eq_const_iff (b : β) (f : α → β) {g : β → γ} (hg : Injective g) :
    g ∘ f = Function.const _ (g b) ↔ f = Function.const _ b 
goal: g ∘ f = Function.const α (g b) ↔ f = Function.const α b

full_name: Function.comp_eq_one_iff
code: @[to_additive]
lemma comp_eq_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f = 1 ↔ f = 1 
goal: g ∘ f = 1 ↔ f = 1

full_name: Function.comp_eq_zero_iff
code: @[to_additive]
lemma comp_eq_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f = 1 ↔ f = 1 
goal: g ∘ f = 0 ↔ f = 0

full_name: Function.comp_ne_zero_iff
code: @[to_additive]
lemma comp_ne_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f ≠ 1 ↔ f ≠ 1 
goal: g ∘ f ≠ 0 ↔ f ≠ 0

full_name: Function.comp_ne_one_iff
code: @[to_additive]
lemma comp_ne_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f ≠ 1 ↔ f ≠ 1 
goal: g ∘ f ≠ 1 ↔ f ≠ 1

full_name: uniqueOfSurjectiveOne
code: /-- If the one function is surjective, the codomain is trivial. -/
@[to_additive "If the zero function is surjective, the codomain is trivial."]
def uniqueOfSurjectiveOne (α : Type*) {β : Type*} [One β] (h : Function.Surjective (1 : α → β)) :
    Unique β 
goal: Unique β

full_name: uniqueOfSurjectiveZero
code: /-- If the one function is surjective, the codomain is trivial. -/
@[to_additive "If the zero function is surjective, the codomain is trivial."]
def uniqueOfSurjectiveOne (α : Type*) {β : Type*} [One β] (h : Function.Surjective (1 : α → β)) :
    Unique β 
goal: Unique β

full_name: Subsingleton.pi_single_eq
code: @[to_additive]
theorem Subsingleton.pi_mulSingle_eq {α : Type*} [DecidableEq I] [Subsingleton I] [One α]
    (i : I) (x : α) : Pi.mulSingle i x = fun _ => x 
goal: Pi.single i x = fun x_1 => x

full_name: Subsingleton.pi_mulSingle_eq
code: @[to_additive]
theorem Subsingleton.pi_mulSingle_eq {α : Type*} [DecidableEq I] [Subsingleton I] [One α]
    (i : I) (x : α) : Pi.mulSingle i x = fun _ => x 
goal: Pi.mulSingle i x = fun x_1 => x

full_name: Sum.elim_one_one
code: @[to_additive (attr := simp)]
theorem elim_one_one [One γ] : Sum.elim (1 : α → γ) (1 : β → γ) = 1 
goal: Sum.elim 1 1 = 1

full_name: Sum.elim_zero_zero
code: @[to_additive (attr := simp)]
theorem elim_one_one [One γ] : Sum.elim (1 : α → γ) (1 : β → γ) = 1 
goal: Sum.elim 0 0 = 0

full_name: Sum.elim_mulSingle_one
code: @[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 
goal: Sum.elim (Pi.mulSingle i c) 1 = Pi.mulSingle (Sum.inl i) c

full_name: Sum.elim_single_zero
code: @[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 
goal: Sum.elim (Pi.single i c) 0 = Pi.single (Sum.inl i) c

full_name: Sum.elim_zero_single
code: @[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 
goal: Sum.elim 0 (Pi.single i c) = Pi.single (Sum.inr i) c

full_name: Sum.elim_one_mulSingle
code: @[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 
goal: Sum.elim 1 (Pi.mulSingle i c) = Pi.mulSingle (Sum.inr i) c

full_name: Sum.elim_inv_inv
code: @[to_additive]
theorem elim_inv_inv [Inv γ] : Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹ 
goal: Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹

full_name: Sum.elim_neg_neg
code: @[to_additive]
theorem elim_inv_inv [Inv γ] : Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹ 
goal: Sum.elim (-a) (-b) = -Sum.elim a b

full_name: Sum.elim_add_add
code: @[to_additive]
theorem elim_mul_mul [Mul γ] : Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b' 
goal: Sum.elim (a + a') (b + b') = Sum.elim a b + Sum.elim a' b'

full_name: Sum.elim_mul_mul
code: @[to_additive]
theorem elim_mul_mul [Mul γ] : Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b' 
goal: Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b'

full_name: Sum.elim_div_div
code: @[to_additive]
theorem elim_div_div [Div γ] : Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b' 
goal: Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b'

full_name: Sum.elim_sub_sub
code: @[to_additive]
theorem elim_div_div [Div γ] : Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b' 
goal: Sum.elim (a - a') (b - b') = Sum.elim a b - Sum.elim a' b'