# Documentation

Mathlib.Algebra.Group.Pi

# Pi instances for groups and monoids #

This file defines instances for group, monoid, semigroup and related structures on Pi types.

theorem Set.preimage_zero {α : Type u_1} {β : Type u_2} [inst : Zero β] (s : Set β) [inst : Decidable (0 s)] :
0 ⁻¹' s = if 0 s then Set.univ else
theorem Set.preimage_one {α : Type u_1} {β : Type u_2} [inst : One β] (s : Set β) [inst : Decidable (1 s)] :
1 ⁻¹' s = if 1 s then Set.univ else
instance Pi.addSemigroup {I : Type u} {f : IType v} [inst : (i : I) → AddSemigroup (f i)] :
AddSemigroup ((i : I) → f i)
Equations
def Pi.addSemigroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddSemigroup (f i)] :
∀ (a b c : (i : I) → f i), a + b + c = a + (b + c)
Equations
• (_ : a + b + c = a + (b + c)) = (_ : a + b + c = a + (b + c))
instance Pi.semigroup {I : Type u} {f : IType v} [inst : (i : I) → Semigroup (f i)] :
Semigroup ((i : I) → f i)
Equations
instance Pi.addCommSemigroup {I : Type u} {f : IType v} [inst : (i : I) → AddCommSemigroup (f i)] :
AddCommSemigroup ((i : I) → f i)
Equations
• Pi.addCommSemigroup = let src := Pi.addSemigroup; AddCommSemigroup.mk (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
def Pi.addCommSemigroup.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommSemigroup (f i)] :
∀ (a b : (i : I) → f i), a + b = b + a
Equations
• (_ : a + b = b + a) = (_ : a + b = b + a)
def Pi.addCommSemigroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommSemigroup (f i)] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b + c = a + (b + c)
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c)) = (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c))
instance Pi.commSemigroup {I : Type u} {f : IType v} [inst : (i : I) → CommSemigroup (f i)] :
CommSemigroup ((i : I) → f i)
Equations
• Pi.commSemigroup = let src := Pi.semigroup; CommSemigroup.mk (_ : ∀ (a b : (i : I) → f i), a * b = b * a)
def Pi.addZeroClass.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddZeroClass (f i)] :
∀ (a : (i : I) → f i), 0 + a = a
Equations
• (_ : 0 + a = a) = (_ : 0 + a = a)
def Pi.addZeroClass.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddZeroClass (f i)] :
∀ (a : (i : I) → f i), a + 0 = a
Equations
• (_ : a + 0 = a) = (_ : a + 0 = a)
instance Pi.addZeroClass {I : Type u} {f : IType v} [inst : (i : I) → AddZeroClass (f i)] :
AddZeroClass ((i : I) → f i)
Equations
• Pi.addZeroClass = AddZeroClass.mk (_ : ∀ (a : (i : I) → f i), 0 + a = a) (_ : ∀ (a : (i : I) → f i), a + 0 = a)
instance Pi.mulOneClass {I : Type u} {f : IType v} [inst : (i : I) → MulOneClass (f i)] :
MulOneClass ((i : I) → f i)
Equations
• Pi.mulOneClass = MulOneClass.mk (_ : ∀ (a : (i : I) → f i), 1 * a = a) (_ : ∀ (a : (i : I) → f i), a * 1 = a)
def Pi.addMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddMonoid (f i)] :
∀ (x : (i : I) → f i), (fun n x i => n x i) 0 x = 0
Equations
• (_ : (fun n x i => n x i) 0 x = 0) = (_ : (fun n x i => n x i) 0 x = 0)
def Pi.addMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
def Pi.addMonoid.proof_5 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddMonoid (f i)] :
∀ (n : ) (x : (i : I) → f i), (fun n x i => n x i) (n + 1) x = x + (fun n x i => n x i) n x
Equations
• (_ : (fun n x i => n x i) (n + 1) x = x + (fun n x i => n x i) n x) = (_ : (fun n x i => n x i) (n + 1) x = x + (fun n x i => n x i) n x)
def Pi.addMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b + c = a + (b + c)
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c)) = (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c))
instance Pi.addMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddMonoid (f i)] :
AddMonoid ((i : I) → f i)
Equations
• Pi.addMonoid = let src := Pi.addSemigroup; let src_1 := Pi.addZeroClass; AddMonoid.mk (_ : ∀ (a : (i : I) → f i), 0 + a = a) (_ : ∀ (a : (i : I) → f i), a + 0 = a) fun n x i => n x i
def Pi.addMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
instance Pi.monoid {I : Type u} {f : IType v} [inst : (i : I) → Monoid (f i)] :
Monoid ((i : I) → f i)
Equations
• Pi.monoid = let src := Pi.semigroup; let src_1 := Pi.mulOneClass; Monoid.mk (_ : ∀ (a : (i : I) → f i), 1 * a = a) (_ : ∀ (a : (i : I) → f i), a * 1 = a) fun n x i => x i ^ n
instance Pi.addMonoidWithOne {I : Type u} {f : IType v} [inst : (i : I) → AddMonoidWithOne (f i)] :
AddMonoidWithOne ((i : I) → f i)
Equations
def Pi.addCommMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
def Pi.addCommMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommMonoid (f i)] (x : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (x : (i : I) → f i), = 0) = (_ : ∀ (x : (i : I) → f i), = 0)
def Pi.addCommMonoid.proof_5 {I : Type u_2} {f : IType u_1} [inst : (i : I) → AddCommMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) :
a + b = b + a
Equations
• (_ : ∀ (a b : (i : I) → f i), a + b = b + a) = (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
def Pi.addCommMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
def Pi.addCommMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommMonoid (f i)] (n : ) (x : (i : I) → f i) :
AddMonoid.nsmul (n + 1) x = x +
Equations
instance Pi.addCommMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddCommMonoid (f i)] :
AddCommMonoid ((i : I) → f i)
Equations
• Pi.addCommMonoid = let src := Pi.addMonoid; let src_1 := Pi.addCommSemigroup; AddCommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
instance Pi.commMonoid {I : Type u} {f : IType v} [inst : (i : I) → CommMonoid (f i)] :
CommMonoid ((i : I) → f i)
Equations
• Pi.commMonoid = let src := Pi.monoid; let src_1 := Pi.commSemigroup; CommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a * b = b * a)
def Pi.subNegMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] (x : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (x : (i : I) → f i), = 0) = (_ : ∀ (x : (i : I) → f i), = 0)
def Pi.subNegMonoid.proof_6 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] :
∀ (a : (i : I) → f i), (fun z x i => z x i) 0 a = 0
Equations
• (_ : (fun z x i => z x i) 0 a = 0) = (_ : (fun z x i => z x i) 0 a = 0)
def Pi.subNegMonoid.proof_7 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] :
∀ (n : ) (a : (i : I) → f i), (fun z x i => z x i) () a = a + (fun z x i => z x i) () a
Equations
• One or more equations did not get rendered due to their size.
def Pi.subNegMonoid.proof_8 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] :
∀ (n : ) (a : (i : I) → f i), (fun z x i => z x i) () a = -(fun z x i => z x i) (↑()) a
Equations
• (_ : (fun z x i => z x i) () a = -(fun z x i => z x i) (↑()) a) = (_ : (fun z x i => z x i) () a = -(fun z x i => z x i) (↑()) a)
def Pi.subNegMonoid.proof_5 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] :
∀ (a b : (i : I) → f i), a - b = a + -b
Equations
def Pi.subNegMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
def Pi.subNegMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] (n : ) (x : (i : I) → f i) :
AddMonoid.nsmul (n + 1) x = x +
Equations
def Pi.subNegMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubNegMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
instance Pi.subNegMonoid {I : Type u} {f : IType v} [inst : (i : I) → SubNegMonoid (f i)] :
SubNegMonoid ((i : I) → f i)
Equations
instance Pi.divInvMonoid {I : Type u} {f : IType v} [inst : (i : I) → DivInvMonoid (f i)] :
DivInvMonoid ((i : I) → f i)
Equations
instance Pi.involutiveNeg {I : Type u} {f : IType v} [inst : (i : I) → InvolutiveNeg (f i)] :
InvolutiveNeg ((i : I) → f i)
Equations
def Pi.involutiveNeg.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → InvolutiveNeg (f i)] :
∀ (x : (i : I) → f i), - -x = x
Equations
instance Pi.involutiveInv {I : Type u} {f : IType v} [inst : (i : I) → InvolutiveInv (f i)] :
InvolutiveInv ((i : I) → f i)
Equations
def Pi.subtractionMonoid.proof_5 {I : Type u_2} {f : IType u_1} [inst : (i : I) → SubtractionMonoid (f i)] (x : (i : I) → f i) :
- -x = x
Equations
• (_ : ∀ (x : (i : I) → f i), - -x = x) = (_ : ∀ (x : (i : I) → f i), - -x = x)
def Pi.subtractionMonoid.proof_6 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] :
∀ (a b : (i : I) → f i), -(a + b) = -b + -a
Equations
def Pi.subtractionMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) :
a - b = a + -b
Equations
• (_ : ∀ (a b : (i : I) → f i), a - b = a + -b) = (_ : ∀ (a b : (i : I) → f i), a - b = a + -b)
def Pi.subtractionMonoid.proof_7 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] :
∀ (a b : (i : I) → f i), a + b = 0-a = b
Equations
• (_ : -a = b) = (_ : -a = b)
instance Pi.subtractionMonoid {I : Type u} {f : IType v} [inst : (i : I) → SubtractionMonoid (f i)] :
SubtractionMonoid ((i : I) → f i)
Equations
• One or more equations did not get rendered due to their size.
def Pi.subtractionMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] (n : ) (a : (i : I) → f i) :
Equations
• One or more equations did not get rendered due to their size.
def Pi.subtractionMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] (a : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (a : (i : I) → f i), = 0) = (_ : ∀ (a : (i : I) → f i), = 0)
def Pi.subtractionMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → SubtractionMonoid (f i)] (n : ) (a : (i : I) → f i) :
= a +
Equations
• One or more equations did not get rendered due to their size.
instance Pi.divisionMonoid {I : Type u} {f : IType v} [inst : (i : I) → DivisionMonoid (f i)] :
DivisionMonoid ((i : I) → f i)
Equations
• One or more equations did not get rendered due to their size.
def Pi.subtractionCommMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] (a : (i : I) → f i) (b : (i : I) → f i) :
-(a + b) = -b + -a
Equations
• (_ : ∀ (a b : (i : I) → f i), -(a + b) = -b + -a) = (_ : ∀ (a b : (i : I) → f i), -(a + b) = -b + -a)
def Pi.subtractionCommMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] (x : (i : I) → f i) :
- -x = x
Equations
• (_ : ∀ (x : (i : I) → f i), - -x = x) = (_ : ∀ (x : (i : I) → f i), - -x = x)
instance Pi.subtractionCommMonoid {I : Type u} {f : IType v} [inst : (i : I) → ] :
SubtractionCommMonoid ((i : I) → f i)
Equations
• Pi.subtractionCommMonoid = let src := Pi.subtractionMonoid; let src_1 := Pi.addCommSemigroup; SubtractionCommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
def Pi.subtractionCommMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] (a : (i : I) → f i) (b : (i : I) → f i) :
a + b = 0-a = b
Equations
• (_ : ∀ (a b : (i : I) → f i), a + b = 0-a = b) = (_ : ∀ (a b : (i : I) → f i), a + b = 0-a = b)
def Pi.subtractionCommMonoid.proof_4 {I : Type u_2} {f : IType u_1} [inst : (i : I) → ] (a : (i : I) → f i) (b : (i : I) → f i) :
a + b = b + a
Equations
• (_ : ∀ (a b : (i : I) → f i), a + b = b + a) = (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
instance Pi.instDivisionCommMonoidForAll {I : Type u} {f : IType v} [inst : (i : I) → DivisionCommMonoid (f i)] :
DivisionCommMonoid ((i : I) → f i)
Equations
• Pi.instDivisionCommMonoidForAll = let src := Pi.divisionMonoid; let src_1 := Pi.commSemigroup; DivisionCommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a * b = b * a)
def Pi.addGroup.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddGroup (f i)] (a : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (a : (i : I) → f i), = 0) = (_ : ∀ (a : (i : I) → f i), = 0)
def Pi.addGroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddGroup (f i)] (a : (i : I) → f i) (b : (i : I) → f i) :
a - b = a + -b
Equations
• (_ : ∀ (a b : (i : I) → f i), a - b = a + -b) = (_ : ∀ (a b : (i : I) → f i), a - b = a + -b)
def Pi.addGroup.proof_5 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddGroup (f i)] :
∀ (a : (i : I) → f i), -a + a = 0
Equations
• (_ : -a + a = 0) = (_ : -a + a = 0)
instance Pi.addGroup {I : Type u} {f : IType v} [inst : (i : I) → AddGroup (f i)] :
AddGroup ((i : I) → f i)
Equations
• Pi.addGroup = let src := Pi.subNegMonoid; AddGroup.mk (_ : ∀ (a : (i : I) → f i), -a + a = 0)
def Pi.addGroup.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddGroup (f i)] (n : ) (a : (i : I) → f i) :
= a +
Equations
• One or more equations did not get rendered due to their size.
def Pi.addGroup.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddGroup (f i)] (n : ) (a : (i : I) → f i) :
Equations
• One or more equations did not get rendered due to their size.
instance Pi.group {I : Type u} {f : IType v} [inst : (i : I) → Group (f i)] :
Group ((i : I) → f i)
Equations
• Pi.group = let src := Pi.divInvMonoid; Group.mk (_ : ∀ (a : (i : I) → f i), a⁻¹ * a = 1)
instance Pi.addGroupWithOne {I : Type u} {f : IType v} [inst : (i : I) → AddGroupWithOne (f i)] :
AddGroupWithOne ((i : I) → f i)
Equations
• Pi.addGroupWithOne = let src := Pi.addGroup; let src_1 := Pi.addMonoidWithOne; AddGroupWithOne.mk SubNegMonoid.zsmul (_ : ∀ (a : (i : I) → f i), -a + a = 0)
instance Pi.addCommGroup {I : Type u} {f : IType v} [inst : (i : I) → AddCommGroup (f i)] :
AddCommGroup ((i : I) → f i)
Equations
• Pi.addCommGroup = let src := Pi.addGroup; let src_1 := Pi.addCommMonoid; AddCommGroup.mk (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
def Pi.addCommGroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCommGroup (f i)] (a : (i : I) → f i) :
-a + a = 0
Equations
• (_ : ∀ (a : (i : I) → f i), -a + a = 0) = (_ : ∀ (a : (i : I) → f i), -a + a = 0)
def Pi.addCommGroup.proof_2 {I : Type u_2} {f : IType u_1} [inst : (i : I) → AddCommGroup (f i)] (a : (i : I) → f i) (b : (i : I) → f i) :
a + b = b + a
Equations
• (_ : ∀ (a b : (i : I) → f i), a + b = b + a) = (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
instance Pi.commGroup {I : Type u} {f : IType v} [inst : (i : I) → CommGroup (f i)] :
CommGroup ((i : I) → f i)
Equations
• Pi.commGroup = let src := Pi.group; let src_1 := Pi.commMonoid; CommGroup.mk (_ : ∀ (a b : (i : I) → f i), a * b = b * a)
def Pi.addLeftCancelSemigroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b + c = a + (b + c)
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c)) = (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c))
def Pi.addLeftCancelSemigroup.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] :
∀ (a b c : (i : I) → f i), a + b = a + cb = c
Equations
• (_ : b = c) = (_ : b = c)
instance Pi.addLeftCancelSemigroup {I : Type u} {f : IType v} [inst : (i : I) → ] :
AddLeftCancelSemigroup ((i : I) → f i)
Equations
instance Pi.leftCancelSemigroup {I : Type u} {f : IType v} [inst : (i : I) → LeftCancelSemigroup (f i)] :
LeftCancelSemigroup ((i : I) → f i)
Equations
def Pi.addRightCancelSemigroup.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b + c = a + (b + c)
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c)) = (_ : ∀ (a b c : (i : I) → f i), a + b + c = a + (b + c))
instance Pi.addRightCancelSemigroup {I : Type u} {f : IType v} [inst : (i : I) → ] :
AddRightCancelSemigroup ((i : I) → f i)
Equations
def Pi.addRightCancelSemigroup.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → ] :
∀ (a b c : (i : I) → f i), a + b = c + ba = c
Equations
• (_ : a = c) = (_ : a = c)
instance Pi.rightCancelSemigroup {I : Type u} {f : IType v} [inst : (i : I) → RightCancelSemigroup (f i)] :
RightCancelSemigroup ((i : I) → f i)
Equations
def Pi.addLeftCancelMonoid.proof_5 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddLeftCancelMonoid (f i)] (n : ) (x : (i : I) → f i) :
AddMonoid.nsmul (n + 1) x = x +
Equations
def Pi.addLeftCancelMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddLeftCancelMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b = a + cb = c
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b = a + cb = c) = (_ : ∀ (a b c : (i : I) → f i), a + b = a + cb = c)
def Pi.addLeftCancelMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddLeftCancelMonoid (f i)] (x : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (x : (i : I) → f i), = 0) = (_ : ∀ (x : (i : I) → f i), = 0)
instance Pi.addLeftCancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddLeftCancelMonoid (f i)] :
AddLeftCancelMonoid ((i : I) → f i)
Equations
• One or more equations did not get rendered due to their size.
def Pi.addLeftCancelMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddLeftCancelMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
def Pi.addLeftCancelMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddLeftCancelMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
instance Pi.leftCancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → LeftCancelMonoid (f i)] :
LeftCancelMonoid ((i : I) → f i)
Equations
• Pi.leftCancelMonoid = let src := Pi.leftCancelSemigroup; let src_1 := Pi.monoid; LeftCancelMonoid.mk (_ : ∀ (a : (i : I) → f i), 1 * a = a) (_ : ∀ (a : (i : I) → f i), a * 1 = a) Monoid.npow
def Pi.addRightCancelMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddRightCancelMonoid (f i)] (x : (i : I) → f i) :
= 0
Equations
• (_ : ∀ (x : (i : I) → f i), = 0) = (_ : ∀ (x : (i : I) → f i), = 0)
def Pi.addRightCancelMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddRightCancelMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b = c + ba = c
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b = c + ba = c) = (_ : ∀ (a b c : (i : I) → f i), a + b = c + ba = c)
def Pi.addRightCancelMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddRightCancelMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
def Pi.addRightCancelMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddRightCancelMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
def Pi.addRightCancelMonoid.proof_5 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddRightCancelMonoid (f i)] (n : ) (x : (i : I) → f i) :
AddMonoid.nsmul (n + 1) x = x +
Equations
instance Pi.addRightCancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddRightCancelMonoid (f i)] :
AddRightCancelMonoid ((i : I) → f i)
Equations
• One or more equations did not get rendered due to their size.
instance Pi.rightCancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → RightCancelMonoid (f i)] :
RightCancelMonoid ((i : I) → f i)
Equations
• Pi.rightCancelMonoid = let src := Pi.rightCancelSemigroup; let src_1 := Pi.monoid; RightCancelMonoid.mk (_ : ∀ (a : (i : I) → f i), 1 * a = a) (_ : ∀ (a : (i : I) → f i), a * 1 = a) Monoid.npow
def Pi.addCancelMonoid.proof_5 {I : Type u_2} {f : IType u_1} [inst : (i : I) → AddCancelMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) (c : (i : I) → f i) :
a + b = c + ba = c
Equations
• (_ : ∀ (a b c : (i : I) → f i), a + b = c + ba = c) = (_ : ∀ (a b c : (i : I) → f i), a + b = c + ba = c)
instance Pi.addCancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddCancelMonoid (f i)] :
AddCancelMonoid ((i : I) → f i)
Equations
• Pi.addCancelMonoid = let src := Pi.addLeftCancelMonoid; let src_1 := Pi.addRightCancelMonoid; AddCancelMonoid.mk (_ : ∀ (a b c : (i : I) → f i), a + b = c + ba = c)
def Pi.addCancelMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelMonoid (f i)] (x : (i : I) → f i) :
Equations
• (_ : ∀ (x : (i : I) → f i), ) = (_ : ∀ (x : (i : I) → f i), )
def Pi.addCancelMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelMonoid (f i)] (n : ) (x : (i : I) → f i) :
Equations
• One or more equations did not get rendered due to their size.
def Pi.addCancelMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
def Pi.addCancelMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
instance Pi.cancelMonoid {I : Type u} {f : IType v} [inst : (i : I) → CancelMonoid (f i)] :
CancelMonoid ((i : I) → f i)
Equations
• Pi.cancelMonoid = let src := Pi.leftCancelMonoid; let src_1 := Pi.rightCancelMonoid; CancelMonoid.mk (_ : ∀ (a b c : (i : I) → f i), a * b = c * ba = c)
def Pi.addCancelCommMonoid.proof_3 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelCommMonoid (f i)] (x : (i : I) → f i) :
Equations
• (_ : ∀ (x : (i : I) → f i), ) = (_ : ∀ (x : (i : I) → f i), )
def Pi.addCancelCommMonoid.proof_2 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelCommMonoid (f i)] (a : (i : I) → f i) :
a + 0 = a
Equations
• (_ : ∀ (a : (i : I) → f i), a + 0 = a) = (_ : ∀ (a : (i : I) → f i), a + 0 = a)
def Pi.addCancelCommMonoid.proof_5 {I : Type u_2} {f : IType u_1} [inst : (i : I) → AddCancelCommMonoid (f i)] (a : (i : I) → f i) (b : (i : I) → f i) :
a + b = b + a
Equations
• (_ : ∀ (a b : (i : I) → f i), a + b = b + a) = (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
instance Pi.addCancelCommMonoid {I : Type u} {f : IType v} [inst : (i : I) → AddCancelCommMonoid (f i)] :
AddCancelCommMonoid ((i : I) → f i)
Equations
• Pi.addCancelCommMonoid = let src := Pi.addLeftCancelMonoid; let src_1 := Pi.addCommMonoid; AddCancelCommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a + b = b + a)
def Pi.addCancelCommMonoid.proof_4 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelCommMonoid (f i)] (n : ) (x : (i : I) → f i) :
Equations
• One or more equations did not get rendered due to their size.
def Pi.addCancelCommMonoid.proof_1 {I : Type u_1} {f : IType u_2} [inst : (i : I) → AddCancelCommMonoid (f i)] (a : (i : I) → f i) :
0 + a = a
Equations
• (_ : ∀ (a : (i : I) → f i), 0 + a = a) = (_ : ∀ (a : (i : I) → f i), 0 + a = a)
instance Pi.cancelCommMonoid {I : Type u} {f : IType v} [inst : (i : I) → CancelCommMonoid (f i)] :
CancelCommMonoid ((i : I) → f i)
Equations
• Pi.cancelCommMonoid = let src := Pi.leftCancelMonoid; let src_1 := Pi.commMonoid; CancelCommMonoid.mk (_ : ∀ (a b : (i : I) → f i), a * b = b * a)
instance Pi.mulZeroClass {I : Type u} {f : IType v} [inst : (i : I) → MulZeroClass (f i)] :
MulZeroClass ((i : I) → f i)
Equations
• Pi.mulZeroClass = MulZeroClass.mk (_ : ∀ (a : (i : I) → f i), 0 * a = 0) (_ : ∀ (a : (i : I) → f i), a * 0 = 0)
instance Pi.mulZeroOneClass {I : Type u} {f : IType v} [inst : (i : I) → MulZeroOneClass (f i)] :
MulZeroOneClass ((i : I) → f i)
Equations
• Pi.mulZeroOneClass = let src := Pi.mulZeroClass; let src_1 := Pi.mulOneClass; MulZeroOneClass.mk (_ : ∀ (a : (i : I) → f i), 0 * a = 0) (_ : ∀ (a : (i : I) → f i), a * 0 = 0)
instance Pi.monoidWithZero {I : Type u} {f : IType v} [inst : (i : I) → MonoidWithZero (f i)] :
MonoidWithZero ((i : I) → f i)
Equations
• Pi.monoidWithZero = let src := Pi.monoid; let src_1 := Pi.mulZeroClass; MonoidWithZero.mk (_ : ∀ (a : (i : I) → f i), 0 * a = 0) (_ : ∀ (a : (i : I) → f i), a * 0 = 0)
instance Pi.commMonoidWithZero {I : Type u} {f : IType v} [inst : (i : I) → CommMonoidWithZero (f i)] :
CommMonoidWithZero ((i : I) → f i)
Equations
• Pi.commMonoidWithZero = let src := Pi.monoidWithZero; let src_1 := Pi.commMonoid; CommMonoidWithZero.mk (_ : ∀ (a : (i : I) → f i), 0 * a = 0) (_ : ∀ (a : (i : I) → f i), a * 0 = 0)
instance Pi.semigroupWithZero {I : Type u} {f : IType v} [inst : (i : I) → SemigroupWithZero (f i)] :
SemigroupWithZero ((i : I) → f i)
Equations
• Pi.semigroupWithZero = let src := Pi.semigroup; let src_1 := Pi.mulZeroClass; SemigroupWithZero.mk (_ : ∀ (a : (i : I) → f i), 0 * a = 0) (_ : ∀ (a : (i : I) → f i), a * 0 = 0)
theorem AddHom.coe_add {M : Type u_1} {N : Type u_2} :
∀ {x : Add M} {x_1 : } (f g : AddHom M N), f + g = fun x_2 => f x_2 + g x_2
theorem MulHom.coe_mul {M : Type u_1} {N : Type u_2} :
∀ {x : Mul M} {x_1 : } (f g : M →ₙ* N), f * g = fun x_2 => f x_2 * g x_2
def Pi.addHom {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → Add (f i)] [inst : Add γ] (g : (i : I) → AddHom γ (f i)) :
AddHom γ ((i : I) → f i)

A family of AddHom's f a : γ → β a→ β a defines an AddHom Pi.addHom f : γ → Π a, β a→ Π a, β a given by Pi.addHom f x b = f b x.

Equations
• = { toFun := fun x i => ↑(g i) x, map_add' := (_ : ∀ (x y : γ), (fun x i => ↑(g i) x) (x + y) = (fun x i => ↑(g i) x) x + (fun x i => ↑(g i) x) y) }
def Pi.addHom.proof_1 {I : Type u_1} {f : IType u_2} {γ : Type u_3} [inst : (i : I) → Add (f i)] [inst : Add γ] (g : (i : I) → AddHom γ (f i)) (x : γ) (y : γ) :
(fun x i => ↑(g i) x) (x + y) = (fun x i => ↑(g i) x) x + (fun x i => ↑(g i) x) y
Equations
• (_ : (fun x i => ↑(g i) x) (x + y) = (fun x i => ↑(g i) x) x + (fun x i => ↑(g i) x) y) = (_ : (fun x i => ↑(g i) x) (x + y) = (fun x i => ↑(g i) x) x + (fun x i => ↑(g i) x) y)
@[simp]
theorem Pi.mulHom_apply {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → Mul (f i)] [inst : Mul γ] (g : (i : I) → γ →ₙ* f i) (x : γ) (i : I) :
↑() x i = ↑(g i) x
@[simp]
theorem Pi.addHom_apply {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → Add (f i)] [inst : Add γ] (g : (i : I) → AddHom γ (f i)) (x : γ) (i : I) :
↑() x i = ↑(g i) x
def Pi.mulHom {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → Mul (f i)] [inst : Mul γ] (g : (i : I) → γ →ₙ* f i) :
γ →ₙ* (i : I) → f i

A family of MulHom's f a : γ →ₙ* β a→ₙ* β a defines a MulHom Pi.mulHom f : γ →ₙ* Π a, β a→ₙ* Π a, β a given by Pi.mulHom f x b = f b x.

Equations
• = { toFun := fun x i => ↑(g i) x, map_mul' := (_ : ∀ (x y : γ), (fun x i => ↑(g i) x) (x * y) = (fun x i => ↑(g i) x) x * (fun x i => ↑(g i) x) y) }
abbrev Pi.addHom_injective.match_1 {I : Type u_1} (motive : Prop) :
(x : ) → ((i : I) → motive (_ : )) → motive x
Equations
theorem Pi.addHom_injective {I : Type u} {f : IType v} {γ : Type w} [inst : ] [inst : (i : I) → Add (f i)] [inst : Add γ] (g : (i : I) → AddHom γ (f i)) (hg : ∀ (i : I), Function.Injective ↑(g i)) :
theorem Pi.mulHom_injective {I : Type u} {f : IType v} {γ : Type w} [inst : ] [inst : (i : I) → Mul (f i)] [inst : Mul γ] (g : (i : I) → γ →ₙ* f i) (hg : ∀ (i : I), Function.Injective ↑(g i)) :
def Pi.addMonoidHom.proof_2 {I : Type u_1} {f : IType u_2} {γ : Type u_3} [inst : (i : I) → AddZeroClass (f i)] [inst : ] (g : (i : I) → γ →+ f i) (x : γ) (y : γ) :
AddHom.toFun (Pi.addHom fun i => ↑(g i)) (x + y) = AddHom.toFun (Pi.addHom fun i => ↑(g i)) x + AddHom.toFun (Pi.addHom fun i => ↑(g i)) y
Equations
• One or more equations did not get rendered due to their size.
def Pi.addMonoidHom.proof_1 {I : Type u_1} {f : IType u_2} {γ : Type u_3} [inst : (i : I) → AddZeroClass (f i)] [inst : ] (g : (i : I) → γ →+ f i) :
(fun x i => ↑(g i) x) 0 = 0
Equations
• (_ : (fun x i => ↑(g i) x) 0 = 0) = (_ : (fun x i => ↑(g i) x) 0 = 0)
def Pi.addMonoidHom {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → AddZeroClass (f i)] [inst : ] (g : (i : I) → γ →+ f i) :
γ →+ (i : I) → f i

A family of additive monoid homomorphisms f a : γ →+ β a→+ β a defines a monoid homomorphism Pi.addMonoidHom f : γ →+ Π a, β a→+ Π a, β a given by Pi.addMonoidHom f x b = f b x.

Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem Pi.monoidHom_apply {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → MulOneClass (f i)] [inst : ] (g : (i : I) → γ →* f i) (x : γ) (i : I) :
↑() x i = ↑(g i) x
@[simp]
theorem Pi.addMonoidHom_apply {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → AddZeroClass (f i)] [inst : ] (g : (i : I) → γ →+ f i) (x : γ) (i : I) :
↑() x i = ↑(g i) x
def Pi.monoidHom {I : Type u} {f : IType v} {γ : Type w} [inst : (i : I) → MulOneClass (f i)] [inst : ] (g : (i : I) → γ →* f i) :
γ →* (i : I) → f i

A family of monoid homomorphisms f a : γ →* β a→* β a defines a monoid homomorphism Pi.monoidHom f : γ →* Π a, β a→* Π a, β a given by Pi.monoidHom f x b = f b x.

Equations
• One or more equations did not get rendered due to their size.
theorem Pi.addMonoidHom_injective {I : Type u} {f : IType v} {γ : Type w} [inst : ] [inst : (i : I) → AddZeroClass (f i)] [inst : ] (g : (i : I) → γ →+ f i) (hg : ∀ (i : I), Function.Injective ↑(g i)) :
theorem Pi.monoidHom_injective {I : Type u} {f : IType v} {γ : Type w} [inst : ] [inst : (i : I) → MulOneClass (f i)] [inst : ] (g : (i : I) → γ →* f i) (hg : ∀ (i : I), Function.Injective ↑(g i)) :
def Pi.evalAddHom.proof_1 {I : Type u_2} (f : IType u_1) [inst : (i : I) → Add (f i)] (i : I) :
∀ (x x_1 : (i : I) → f i), (((i : I) → f i) + ((i : I) → f i)) ((i : I) → f i) instHAdd x x_1 i = x i + x_1 i
Equations
def Pi.evalAddHom {I : Type u} (f : IType v) [inst : (i : I) → Add (f i)] (i : I) :
AddHom ((i : I) → f i) (f i)

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.

Equations
• = { toFun := fun g => g i, map_add' := (_ : ∀ (x x_1 : (i : I) → f i), (((i : I) → f i) + ((i : I) → f i)) ((i : I) → f i) instHAdd x x_1 i = x i + x_1 i) }
@[simp]
theorem Pi.evalAddHom_apply {I : Type u} (f : IType v) [inst : (i : I) → Add (f i)] (i : I) (g : (i : I) → f i) :
↑() g = g i
@[simp]
theorem Pi.evalMulHom_apply {I : Type u} (f : IType v) [inst : (i : I) → Mul (f i)] (i : I) (g : (i : I) → f i) :
↑() g = g i
def Pi.evalMulHom {I : Type u} (f : IType v) [inst : (i : I) → Mul (f i)] (i : I) :
((i : I) → f i) →ₙ* f i

Evaluation of functions into an indexed collection of semigroups at a point is a semigroup homomorphism. This is Function.eval i as a MulHom.

Equations
• = { toFun := fun g => g i, map_mul' := (_ : ∀ (x x_1 : (i : I) → f i), (((i : I) → f i) * ((i : I) → f i)) ((i : I) → f i) instHMul x x_1 i = x i * x_1 i) }
def Pi.constAddHom.proof_1 (α : Type u_1) (β : Type u_2) [inst : Add β] :
∀ (x x_1 : β), Function.const α (x + x_1) = Function.const α (x + x_1)
Equations
def Pi.constAddHom (α : Type u_1) (β : Type u_2) [inst : Add β] :

Function.const as an AddHom.

Equations
@[simp]
theorem Pi.constAddHom_apply (α : Type u_1) (β : Type u_2) [inst : Add β] (a : β) :
∀ (a : α), ↑() a a =
@[simp]
theorem Pi.constMulHom_apply (α : Type u_1) (β : Type u_2) [inst : Mul β] (a : β) :
∀ (a : α), ↑() a a =
def Pi.constMulHom (α : Type u_1) (β : Type u_2) [inst : Mul β] :
β →ₙ* αβ

Function.const as a MulHom.

Equations
def AddHom.coeFn.proof_1 (α : Type u_1) (β : Type u_2) [inst : Add α] [inst : ] :
∀ (x x_1 : AddHom α β), (fun g => g) (x + x_1) = (fun g => g) (x + x_1)
Equations
• (_ : (fun g => g) (x + x) = (fun g => g) (x + x)) = (_ : (fun g => g) (x + x) = (fun g => g) (x + x))
def AddHom.coeFn (α : Type u_1) (β : Type u_2) [inst : Add α] [inst : ] :

Coercion of an AddHom into a function is itself an AddHom.

See also AddHom.eval.

Equations
• = { toFun := fun g => g, map_add' := (_ : ∀ (x x_1 : AddHom α β), (fun g => g) (x + x_1) = (fun g => g) (x + x_1)) }
@[simp]
theorem AddHom.coeFn_apply (α : Type u_1) (β : Type u_2) [inst : Add α] [inst : ] (g : AddHom α β) (a : α) :
↑() g a = g a
@[simp]
theorem MulHom.coeFn_apply (α : Type u_1) (β : Type u_2) [inst : Mul α] [inst : ] (g : α →ₙ* β) (a : α) :
↑() g a = g a
def MulHom.coeFn (α : Type u_1) (β : Type u_2) [inst : Mul α] [inst : ] :
(α →ₙ* β) →ₙ* αβ

Coercion of a MulHom into a function is itself a MulHom.

See also MulHom.eval.

Equations
• = { toFun := fun g => g, map_mul' := (_ : ∀ (x x_1 : α →ₙ* β), (fun g => g) (x * x_1) = (fun g => g) (x * x_1)) }
def AddHom.compLeft.proof_1 {α : Type u_3} {β : Type u_2} [inst : Add α] [inst : Add β] (f : AddHom α β) (I : Type u_1) :
∀ (x x_1 : Iα), (fun h => f h) (x + x_1) = (fun h => f h) x + (fun h => f h) x_1
Equations
• (_ : (fun h => f h) (x + x) = (fun h => f h) x + (fun h => f h) x) = (_ : (fun h => f h) (x + x) = (fun h => f h) x + (fun h => f h) x)
def AddHom.compLeft {α : Type u_1} {β : Type u_2} [inst : Add α] [inst : Add β] (f : AddHom α β) (I : Type u_3) :

Additive semigroup homomorphism between the function spaces I → α→ α and I → β→ β, induced by an additive semigroup homomorphism f between α and β

Equations
• = { toFun := fun h => f h, map_add' := (_ : ∀ (x x_1 : Iα), (fun h => f h) (x + x_1) = (fun h => f h) x + (fun h => f h) x_1) }
@[simp]
theorem MulHom.compLeft_apply {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst : Mul β] (f : α →ₙ* β) (I : Type u_3) (h : Iα) :
∀ (a : I), ↑() h a = (f h) a
@[simp]
theorem AddHom.compLeft_apply {α : Type u_1} {β : Type u_2} [inst : Add α] [inst : Add β] (f : AddHom α β) (I : Type u_3) (h : Iα) :
∀ (a : I), ↑() h a = (f h) a
def MulHom.compLeft {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst : Mul β] (f : α →ₙ* β) (I : Type u_3) :
(Iα) →ₙ* Iβ

Semigroup homomorphism between the function spaces I → α→ α and I → β→ β, induced by a semigroup homomorphism f between α and β.

Equations
• = { toFun := fun h => f h, map_mul' := (_ : ∀ (x x_1 : Iα), (fun h => f h) (x * x_1) = (fun h => f h) x * (fun h => f h) x_1) }
def Pi.evalAddMonoidHom.proof_2 {I : Type u_2} (f : IType u_1) [inst : (i : I) → AddZeroClass (f i)] (i : I) :
∀ (x x_1 : (i : I) → f i), (((i : I) → f i) + ((i : I) → f i)) ((i : I) → f i) instHAdd x x_1 i = x i + x_1 i
Equations
def Pi.evalAddMonoidHom {I : Type u} (f : IType v) [inst : (i : I) → AddZeroClass (f i)] (i : I) :
((i : I) → f i) →+ f i

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.

Equations
• One or more equations did not get rendered due to their size.
def Pi.evalAddMonoidHom.proof_1 {I : Type u_2} (f : IType u_1) [inst : (i : I) → AddZeroClass (f i)] (i : I) :
OfNat.ofNat ((i : I) → f i) 0 Zero.toOfNat0 i = 0
Equations
@[simp]
theorem Pi.evalMonoidHom_apply {I : Type u} (f : IType v) [inst : (i : I) → MulOneClass (f i)] (i : I) (g : (i : I) → f i) :
↑() g = g i
@[simp]
theorem Pi.evalAddMonoidHom_apply {I : Type u} (f : IType v) [inst : (i : I) → AddZeroClass (f i)] (i : I) (g : (i : I) → f i) :
↑() g = g i
def Pi.evalMonoidHom {I : Type u} (f : IType v) [inst : (i : I) → MulOneClass (f i)] (i : I) :
((i : I) → f i) →* f i

Evaluation of functions into an indexed collection of monoids at a point is a monoid homomorphism. This is Function.eval i as a MonoidHom.

Equations
• One or more equations did not get rendered due to their size.
def Pi.constAddMonoidHom.proof_2 (α : Type u_1) (β : Type u_2) [inst : ] :
∀ (x x_1 : β), ZeroHom.toFun { toFun := , map_zero' := (_ : = ) } (x + x_1) = ZeroHom.toFun { toFun := , map_zero' := (_ : = ) } (x + x_1)
Equations
• One or more equations did not get rendered due to their size.
def Pi.constAddMonoidHom.proof_1 (α : Type u_1) (β : Type u_2) [inst : ] :
=
Equations
• (_ : = ) = (_ : = )
def Pi.constAddMonoidHom (α : Type u_1) (β : Type u_2) [inst : ] :
β →+ αβ

Function.const as an AddMonoidHom.

Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem Pi.constAddMonoidHom_apply (α : Type u_1) (β : Type u_2) [inst : ] (a : β) :
∀ (a : α), ↑() a a =
@[simp]
theorem Pi.constMonoidHom_apply (α : Type u_1) (β : Type u_2) [inst : ] (a : β) :
∀ (a : α), ↑() a a =
def Pi.constMonoidHom (α : Type u_1) (β : Type u_2) [inst : ] :
β →* αβ

Function.const as a MonoidHom.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.coeFn (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] :
(α →+ β) →+ αβ

Coercion of an AddMonoidHom into a function is itself a AddMonoidHom.

See also AddMonoidHom.eval.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.coeFn.proof_1 (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] :
(fun g => g) 0 = (fun g => g) 0
Equations
• (_ : (fun g => g) 0 = (fun g => g) 0) = (_ : (fun g => g) 0 = (fun g => g) 0)
def AddMonoidHom.coeFn.proof_2 (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] :
∀ (x x_1 : α →+ β), ZeroHom.toFun { toFun := fun g => g, map_zero' := (_ : (fun g => g) 0 = (fun g => g) 0) } (x + x_1) = ZeroHom.toFun { toFun := fun g => g, map_zero' := (_ : (fun g => g) 0 = (fun g => g) 0) } (x + x_1)
Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem MonoidHom.coeFn_apply (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] (g : α →* β) (a : α) :
↑() g a = g a
@[simp]
theorem AddMonoidHom.coeFn_apply (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] (g : α →+ β) (a : α) :
↑() g a = g a
def MonoidHom.coeFn (α : Type u_1) (β : Type u_2) [inst : ] [inst : ] :
(α →* β) →* αβ

Coercion of a MonoidHom into a function is itself a MonoidHom.

See also MonoidHom.eval.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compLeft.proof_2 {α : Type u_3} {β : Type u_2} [inst : ] [inst : ] (f : α →+ β) (I : Type u_1) :
∀ (x x_1 : Iα), ZeroHom.toFun { toFun := fun h => f h, map_zero' := (_ : (fun h => f h) 0 = 0) } (x + x_1) = ZeroHom.toFun { toFun := fun h => f h, map_zero' := (_ : (fun h => f h) 0 = 0) } x + ZeroHom.toFun { toFun := fun h => f h, map_zero' := (_ : (fun h => f h) 0 = 0) } x_1
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compLeft {α : Type u_1} {β : Type u_2} [inst : ] [inst : ] (f : α →+ β) (I : Type u_3) :
(Iα) →+ Iβ

Additive monoid homomorphism between the function spaces I → α→ α and I → β→ β, induced by an additive monoid homomorphism f between α and β

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compLeft.proof_1 {α : Type u_3} {β : Type u_2} [inst : ] [inst : ] (f : α →+ β) (I : Type u_1) :
(fun h => f h) 0 = 0
Equations
• (_ : (fun h => f h) 0 = 0) = (_ : (fun h => f h) 0 = 0)
@[simp]
theorem AddMonoidHom.compLeft_apply {α : Type u_1} {β : Type u_2} [inst : ] [inst : ] (f : α →+ β) (I : Type u_3) (h : Iα) :
∀ (a : I), ↑() h a = (f h) a
@[simp]
theorem MonoidHom.compLeft_apply {α : Type u_1} {β : Type u_2} [inst : ] [inst : ] (f : α →* β) (I : Type u_3) (h : Iα) :
∀ (a : I), ↑() h a = (f h) a
def MonoidHom.compLeft {α : Type u_1} {β : Type u_2} [inst : ] [inst : ] (f : α →* β) (I : Type u_3) :
(Iα) →* Iβ

Monoid homomorphism between the function spaces I → α→ α and I → β→ β, induced by a monoid homomorphism f between α and β.

Equations
• One or more equations did not get rendered due to their size.
def ZeroHom.single.proof_1 {I : Type u_1} (f : IType u_2) [inst : ] [inst : (i : I) → Zero (f i)] (i : I) :
= 0
Equations
• (_ : = 0) = (_ : = 0)
def ZeroHom.single {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → Zero (f i)] (i : I) :
ZeroHom (f i) ((i : I) → f i)

The zero-preserving homomorphism including a single value into a dependent family of values, as functions supported at a point.

This is the ZeroHom version of Pi.single.

Equations
• = { toFun := , map_zero' := (_ : = 0) }
def OneHom.single {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → One (f i)] (i : I) :
OneHom (f i) ((i : I) → f i)

The one-preserving homomorphism including a single value into a dependent family of values, as functions supported at a point.

This is the OneHom version of Pi.mulSingle.

Equations
• = { toFun := , map_one' := (_ : = 1) }
@[simp]
theorem ZeroHom.single_apply {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → Zero (f i)] (i : I) (x : f i) :
↑() x =
@[simp]
theorem OneHom.single_apply {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → One (f i)] (i : I) (x : f i) :
↑() x =
def AddMonoidHom.single {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → AddZeroClass (f i)] (i : I) :
f i →+ (i : I) → f i

The additive monoid homomorphism including a single additive monoid into a dependent family of additive monoids, as functions supported at a point.

This is the AddMonoidHom version of Pi.single.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.single.proof_2 {I : Type u_1} (f : IType u_2) [inst : ] [inst : (i : I) → AddZeroClass (f i)] (i : I) (x₁ : f i) (x₂ : f i) :
Pi.single i (x₁ + x₂) = fun j => Pi.single i x₁ j + Pi.single i x₂ j
Equations
def AddMonoidHom.single.proof_1 {I : Type u_1} (f : IType u_2) [inst : ] [inst : (i : I) → AddZeroClass (f i)] (i : I) :
Equations
def MonoidHom.single {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → MulOneClass (f i)] (i : I) :
f i →* (i : I) → f i

The monoid homomorphism including a single monoid into a dependent family of additive monoids, as functions supported at a point.

This is the MonoidHom version of Pi.mulSingle.

Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem AddMonoidHom.single_apply {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → AddZeroClass (f i)] (i : I) (x : f i) :
↑() x =
@[simp]
theorem MonoidHom.single_apply {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → MulOneClass (f i)] (i : I) (x : f i) :
↑() x =
@[simp]
theorem MulHom.single_apply {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → MulZeroClass (f i)] (i : I) (x : f i) (j : I) :
↑() x j = Pi.single i x j
def MulHom.single {I : Type u} (f : IType v) [inst : ] [inst : (i : I) → MulZeroClass (f i)] (i : I) :
f i →ₙ* (i : I) → f i

The multiplicative homomorphism including a single MulZeroClass into a dependent family of MulZeroClasses, as functions supported at a point.

This is the MulHom version of Pi.single.

Equations
theorem Pi.single_add {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → AddZeroClass (f i)] (i : I) (x : f i) (y : f i) :
Pi.single i (x + y) = +
theorem Pi.mulSingle_mul {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → MulOneClass (f i)] (i : I) (x : f i) (y : f i) :
Pi.mulSingle i (x * y) = *
theorem Pi.single_neg {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → AddGroup (f i)] (i : I) (x : f i) :
Pi.single i (-x) = -
theorem Pi.mulSingle_inv {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → Group (f i)] (i : I) (x : f i) :
= ()⁻¹
theorem Pi.single_sub {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → AddGroup (f i)] (i : I) (x : f i) (y : f i) :
Pi.single i (x - y) = -
theorem Pi.single_div {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → Group (f i)] (i : I) (x : f i) (y : f i) :
Pi.mulSingle i (x / y) = /
theorem Pi.single_mul {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → MulZeroClass (f i)] (i : I) (x : f i) (y : f i) :
Pi.single i (x * y) = *
theorem Pi.single_commute {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → AddZeroClass (f i)] :
Pairwise fun i j => ∀ (x : f i) (y : f j), AddCommute () ()

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 : Type u} {f : IType v} [inst : ] [inst : (i : I) → MulOneClass (f i)] :
Pairwise fun i j => ∀ (x : f i) (y : f j), Commute () ()

The injection into a pi group at different indices commutes.

For injections of commuting elements at the same index, see Commute.map

theorem Pi.single_apply_commute {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → AddZeroClass (f i)] (x : (i : I) → f i) (i : I) (j : I) :
AddCommute (Pi.single i (x i)) (Pi.single j (x j))

The injection into an additive pi group with the same values commutes.

theorem Pi.mulSingle_apply_commute {I : Type u} {f : IType v} [inst : ] [inst : (i : I) → MulOneClass (f i)] (x : (i : I) → f i) (i : I) (j : I) :
Commute (Pi.mulSingle i (x i)) (Pi.mulSingle j (x j))

The injection into a pi group with the same values commutes.

theorem Pi.update_eq_sub_add_single {I : Type u} {f : IType v} (i : I) [inst : ] [inst : (i : I) → AddGroup (f i)] (g : (i : I) → f i) (x : f i) :
= g - Pi.single i (g i) +
theorem Pi.update_eq_div_mul_mulSingle {I : Type u} {f : IType v} (i : I) [inst : ] [inst : (i : I) → Group (f i)] (g : (i : I) → f i) (x : f i) :
= g / Pi.mulSingle i (g i) *
theorem Pi.single_add_single_eq_single_add_single {I : Type u} [inst : ] {M : Type u_1} [inst : ] {k : I} {l : I} {m : I} {n : I} {u : M} {v : M} (hu : u 0) (hv : v 0) :
+ = + k = m l = n u = v k = n l = m u + v = 0 k = l m = n
theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {I : Type u} [inst : ] {M : Type u_1} [inst : ] {k : I} {l : I} {m : I} {n : I} {u : M} {v : M} (hu : u 1) (hv : v 1) :
* = * k = m l = n u = v k = n l = m u * v = 1 k = l m = n
@[simp]
theorem Function.update_zero {I : Type u} {f : IType v} [inst : (i : I) → Zero (f i)] [inst : ] (i : I) :
= 0
@[simp]
theorem Function.update_one {I : Type u} {f : IType v} [inst : (i : I) → One (f i)] [inst : ] (i : I) :
= 1
theorem Function.update_add {I : Type u} {f : IType v} [inst : (i : I) → Add (f i)] [inst : ] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (i : I) (x₁ : f i) (x₂ : f i) :
Function.update (f₁ + f₂) i (x₁ + x₂) = Function.update f₁ i x₁ + Function.update f₂ i x₂
theorem Function.update_mul {I : Type u} {f : IType v} [inst : (i : I) → Mul (f i)] [inst : ] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (i : I) (x₁ : f i) (x₂ : f i) :
Function.update (f₁ * f₂) i (x₁ * x₂) = Function.update f₁ i x₁ * Function.update f₂ i x₂
theorem Function.update_neg {I : Type u} {f : IType v} [inst : (i : I) → Neg (f i)] [inst : ] (f₁ : (i : I) → f i) (i : I) (x₁ : f i) :
Function.update (-f₁) i (-x₁) = -Function.update f₁ i x₁
theorem Function.update_inv {I : Type u} {f : IType v} [inst : (i : I) → Inv (f i)] [inst : ] (f₁ : (i : I) → f i) (i : I) (x₁ : f i) :
theorem Function.update_sub {I : Type u} {f : IType v} [inst : (i : I) → Sub (f i)] [inst : ] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (i : I) (x₁ : f i) (x₂ : f i) :
Function.update (f₁ - f₂) i (x₁ - x₂) = Function.update f₁ i x₁ - Function.update f₂ i x₂
theorem Function.update_div {I : Type u} {f : IType v} [inst : (i : I) → Div (f i)] [inst : ] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (i : I) (x₁ : f i) (x₂ : f i) :
Function.update (f₁ / f₂) i (x₁ / x₂) = Function.update f₁ i x₁ / Function.update f₂ i x₂
@[simp]
theorem Function.const_eq_zero {ι : Type u_1} {α : Type u_2} [inst : Zero α] [inst : ] {a : α} :
= 0 a = 0
@[simp]
theorem Function.const_eq_one {ι : Type u_1} {α : Type u_2} [inst : One α] [inst : ] {a : α} :
= 1 a = 1
theorem Function.const_ne_zero {ι : Type u_1} {α : Type u_2} [inst : Zero α] [inst : ] {a : α} :
0 a 0
theorem Function.const_ne_one {ι : Type u_1} {α : Type u_2} [inst : One α] [inst : ] {a : α} :
1 a 1
theorem Set.piecewise_add {I : Type u} {f : IType v} [inst : (i : I) → Add (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (g₁ : (i : I) → f i) (g₂ : (i : I) → f i) :
Set.piecewise s (f₁ + f₂) (g₁ + g₂) = Set.piecewise s f₁ g₁ + Set.piecewise s f₂ g₂
theorem Set.piecewise_mul {I : Type u} {f : IType v} [inst : (i : I) → Mul (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (g₁ : (i : I) → f i) (g₂ : (i : I) → f i) :
Set.piecewise s (f₁ * f₂) (g₁ * g₂) = Set.piecewise s f₁ g₁ * Set.piecewise s f₂ g₂
theorem Set.piecewise_neg {I : Type u} {f : IType v} [inst : (i : I) → Neg (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (g₁ : (i : I) → f i) :
Set.piecewise s (-f₁) (-g₁) = -Set.piecewise s f₁ g₁
theorem Set.piecewise_inv {I : Type u} {f : IType v} [inst : (i : I) → Inv (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (g₁ : (i : I) → f i) :
Set.piecewise s f₁⁻¹ g₁⁻¹ = (Set.piecewise s f₁ g₁)⁻¹
theorem Set.piecewise_sub {I : Type u} {f : IType v} [inst : (i : I) → Sub (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (g₁ : (i : I) → f i) (g₂ : (i : I) → f i) :
Set.piecewise s (f₁ - f₂) (g₁ - g₂) = Set.piecewise s f₁ g₁ - Set.piecewise s f₂ g₂
theorem Set.piecewise_div {I : Type u} {f : IType v} [inst : (i : I) → Div (f i)] (s : Set I) [inst : (i : I) → Decidable (i s)] (f₁ : (i : I) → f i) (f₂ : (i : I) → f i) (g₁ : (i : I) → f i) (g₂ : (i : I) → f i) :
Set.piecewise s (f₁ / f₂) (g₁ / g₂) = Set.piecewise s f₁ g₁ / Set.piecewise s f₂ g₂
noncomputable def Function.ExtendByZero.hom {ι : Type u_1} {η : Type v} (R : Type w) (s : ιη) [inst : ] :
(ιR) →+ ηR

Function.extend s f 0 as a bundled hom.

Equations
• One or more equations did not get rendered due to their size.
def Function.ExtendByZero.hom.proof_1 {ι : Type u_3} {η : Type u_1} (R : Type u_2) (s : ιη) [inst : ] :
= 0
Equations
• (_ : = 0) = (_ : = 0)
def Function.ExtendByZero.hom.proof_2 {ι : Type u_3} {η : Type u_1} (R : Type u_2) (s : ιη) [inst : ] (f : ιR) (g : ιR) :
ZeroHom.toFun { toFun := fun f => , map_zero' := (_ : = 0) } (f + g) = ZeroHom.toFun { toFun := fun f => , map_zero' := (_ : = 0) } f + ZeroHom.toFun { toFun := fun f => , map_zero' := (_ : = 0) } g
Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem Function.ExtendByOne.hom_apply {ι : Type u_1} {η : Type v} (R : Type w) (s : ιη) [inst : ] (f : ιR) :
∀ (a : η), ↑() f a = Function.extend s f 1 a
@[simp]
theorem Function.ExtendByZero.hom_apply {ι : Type u_1} {η : Type v} (R : Type w) (s : ιη) [inst : ] (f : ιR) :
∀ (a : η), ↑() f a = Function.extend s f 0 a
noncomputable def Function.ExtendByOne.hom {ι : Type u_1} {η : Type v} (R : Type w) (s : ιη) [inst : ] :
(ιR) →* ηR

Function.extend s f 1 as a bundled hom.

Equations
• One or more equations did not get rendered due to their size.