Decompositions of additive monoids, groups, and modules into direct sums #
Main definitions #
DirectSum.Decomposition ℳ: A typeclass to provide a constructive decomposition from an additive monoidMinto a family of additive submonoidsℳDirectSum.decompose ℳ: The canonical equivalence provided by the above typeclass
Main statements #
DirectSum.Decomposition.isInternal: The link toDirectSum.IsInternal.
Implementation details #
As we want to talk about different types of decomposition (additive monoids, modules, rings, ...),
we choose to avoid heavily bundling DirectSum.decompose, instead making copies for the
AddEquiv, LinearEquiv, etc. This means we have to repeat statements that follow from these
bundled homs, but means we don't have to repeat statements for different types of decomposition.
class
DirectSum.Decomposition
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
:
Type (max u_1 u_3)
- decompose' : M → ⨁ (i : ι), { x // x ∈ ℳ i }
- left_inv : Function.LeftInverse (↑(DirectSum.coeAddMonoidHom ℳ)) DirectSum.Decomposition.decompose'
- right_inv : Function.RightInverse (↑(DirectSum.coeAddMonoidHom ℳ)) DirectSum.Decomposition.decompose'
A decomposition is an equivalence between an additive monoid M and a direct sum of additive
submonoids ℳ i of that M, such that the "recomposition" is canonical. This definition also
works for additive groups and modules.
This is a version of DirectSum.IsInternal which comes with a constructive inverse to the
canonical "recomposition" rather than just a proof that the "recomposition" is bijective.
Instances
instance
DirectSum.instSubsingletonDecomposition
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
:
DirectSum.Decomposition instances, while carrying data, are always equal.
theorem
DirectSum.Decomposition.isInternal
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
def
DirectSum.decompose
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
If M is graded by ι with degree i component ℳ i, then it is isomorphic as
to a direct sum of components. This is the canonical spelling of the decompose' field.
Equations
- One or more equations did not get rendered due to their size.
Instances For
theorem
DirectSum.Decomposition.inductionOn
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{p : M → Prop}
(h_zero : p 0)
(h_homogeneous : {i : ι} → (m : { x // x ∈ ℳ i }) → p ↑m)
(h_add : (m m' : M) → p m → p m' → p (m + m'))
(m : M)
:
p m
@[simp]
theorem
DirectSum.Decomposition.decompose'_eq
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
DirectSum.Decomposition.decompose' = ↑(DirectSum.decompose ℳ)
@[simp]
theorem
DirectSum.decompose_symm_of
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{i : ι}
(x : { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ).symm (↑(DirectSum.of (fun i => { x // x ∈ ℳ i }) i) x) = ↑x
@[simp]
theorem
DirectSum.decompose_coe
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{i : ι}
(x : { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ) ↑x = ↑(DirectSum.of (fun i => { x // x ∈ ℳ i }) i) x
theorem
DirectSum.decompose_of_mem
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{x : M}
{i : ι}
(hx : x ∈ ℳ i)
:
↑(DirectSum.decompose ℳ) x = ↑(DirectSum.of (fun i => { x // x ∈ ℳ i }) i) { val := x, property := hx }
theorem
DirectSum.decompose_of_mem_same
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{x : M}
{i : ι}
(hx : x ∈ ℳ i)
:
↑(↑(↑(DirectSum.decompose ℳ) x) i) = x
theorem
DirectSum.decompose_of_mem_ne
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{x : M}
{i : ι}
{j : ι}
(hx : x ∈ ℳ i)
(hij : i ≠ j)
:
↑(↑(↑(DirectSum.decompose ℳ) x) j) = 0
def
DirectSum.decomposeAddEquiv
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
If M is graded by ι with degree i component ℳ i, then it is isomorphic as
an additive monoid to a direct sum of components.
Equations
- One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem
DirectSum.decomposeAddEquiv_apply
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(a : M)
:
↑(DirectSum.decomposeAddEquiv ℳ) a = ↑(DirectSum.decompose ℳ) a
@[simp]
theorem
DirectSum.decomposeAddEquiv_symm_apply
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(a : ⨁ (i : ι), { x // x ∈ ℳ i })
:
↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)) a = ↑(DirectSum.decompose ℳ).symm a
@[simp]
theorem
DirectSum.decompose_zero
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
↑(DirectSum.decompose ℳ) 0 = 0
@[simp]
theorem
DirectSum.decompose_symm_zero
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
:
↑(DirectSum.decompose ℳ).symm 0 = 0
@[simp]
theorem
DirectSum.decompose_add
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : M)
(y : M)
:
↑(DirectSum.decompose ℳ) (x + y) = ↑(DirectSum.decompose ℳ) x + ↑(DirectSum.decompose ℳ) y
@[simp]
theorem
DirectSum.decompose_symm_add
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : ⨁ (i : ι), { x // x ∈ ℳ i })
(y : ⨁ (i : ι), { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ).symm (x + y) = ↑(DirectSum.decompose ℳ).symm x + ↑(DirectSum.decompose ℳ).symm y
@[simp]
theorem
DirectSum.decompose_sum
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{ι' : Type u_5}
(s : Finset ι')
(f : ι' → M)
:
↑(DirectSum.decompose ℳ) (Finset.sum s fun i => f i) = Finset.sum s fun i => ↑(DirectSum.decompose ℳ) (f i)
@[simp]
theorem
DirectSum.decompose_symm_sum
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{ι' : Type u_5}
(s : Finset ι')
(f : ι' → ⨁ (i : ι), { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ).symm (Finset.sum s fun i => f i) = Finset.sum s fun i => ↑(DirectSum.decompose ℳ).symm (f i)
theorem
DirectSum.sum_support_decompose
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
[(i : ι) → (x : { x // x ∈ ℳ i }) → Decidable (x ≠ 0)]
(r : M)
:
(Finset.sum (DFinsupp.support (↑(DirectSum.decompose ℳ) r)) fun i => ↑(↑(↑(DirectSum.decompose ℳ) r) i)) = r
instance
DirectSum.addCommGroupSetLike
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[AddCommGroup M]
[SetLike σ M]
[AddSubgroupClass σ M]
(ℳ : ι → σ)
:
AddCommGroup (⨁ (i : ι), { x // x ∈ ℳ i })
The - in the statements below doesn't resolve without this line.
This seems to be a problem of synthesized vs inferred typeclasses disagreeing. If we replace
the statement of decompose_neg with @Eq (⨁ i, ℳ i) (decompose ℳ (-x)) (-decompose ℳ x)
instead of decompose ℳ (-x) = -decompose ℳ x, which forces the typeclasses needed by ⨁ i, ℳ i
to be found by unification rather than synthesis, then everything works fine without this
instance.
Equations
- DirectSum.addCommGroupSetLike ℳ = inferInstance
@[simp]
theorem
DirectSum.decompose_neg
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommGroup M]
[SetLike σ M]
[AddSubgroupClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : M)
:
↑(DirectSum.decompose ℳ) (-x) = -↑(DirectSum.decompose ℳ) x
@[simp]
theorem
DirectSum.decompose_symm_neg
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommGroup M]
[SetLike σ M]
[AddSubgroupClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : ⨁ (i : ι), { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ).symm (-x) = -↑(DirectSum.decompose ℳ).symm x
@[simp]
theorem
DirectSum.decompose_sub
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommGroup M]
[SetLike σ M]
[AddSubgroupClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : M)
(y : M)
:
↑(DirectSum.decompose ℳ) (x - y) = ↑(DirectSum.decompose ℳ) x - ↑(DirectSum.decompose ℳ) y
@[simp]
theorem
DirectSum.decompose_symm_sub
{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommGroup M]
[SetLike σ M]
[AddSubgroupClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
(x : ⨁ (i : ι), { x // x ∈ ℳ i })
(y : ⨁ (i : ι), { x // x ∈ ℳ i })
:
↑(DirectSum.decompose ℳ).symm (x - y) = ↑(DirectSum.decompose ℳ).symm x - ↑(DirectSum.decompose ℳ).symm y
@[simp]
theorem
DirectSum.decomposeLinearEquiv_apply
{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
[DecidableEq ι]
[Semiring R]
[AddCommMonoid M]
[Module R M]
(ℳ : ι → Submodule R M)
[DirectSum.Decomposition ℳ]
:
↑(DirectSum.decomposeLinearEquiv ℳ) = ↑(LinearMap.inverse
{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) }
↑(DirectSum.decomposeAddEquiv ℳ)
(_ :
Function.LeftInverse ↑(DirectSum.decomposeAddEquiv ℳ)
↑{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) })
(_ :
Function.RightInverse ↑(DirectSum.decomposeAddEquiv ℳ)
↑{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) }))
@[simp]
theorem
DirectSum.decomposeLinearEquiv_symm_apply
{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
[DecidableEq ι]
[Semiring R]
[AddCommMonoid M]
[Module R M]
(ℳ : ι → Submodule R M)
[DirectSum.Decomposition ℳ]
:
↑(LinearEquiv.symm (DirectSum.decomposeLinearEquiv ℳ)) = ↑(↑(LinearEquiv.symm
{
toLinearMap :=
{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) },
invFun := ↑(DirectSum.decomposeAddEquiv ℳ),
left_inv :=
(_ :
Function.LeftInverse ↑(DirectSum.decomposeAddEquiv ℳ)
{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) }.toAddHom.toFun),
right_inv :=
(_ :
Function.RightInverse ↑(DirectSum.decomposeAddEquiv ℳ)
{
toAddHom :=
{ toFun := ↑(AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)),
map_add' :=
(_ :
∀ (x y : ⨁ (i : ι), { x // x ∈ ℳ i }),
Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv (x + y) = Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv x + Equiv.toFun (AddEquiv.symm (DirectSum.decomposeAddEquiv ℳ)).toEquiv y) },
map_smul' :=
(_ :
∀ (c : R) (x : ⨁ (i : ι), { x // x ∈ ℳ i }),
↑(DirectSum.coeLinearMap ℳ) (c • x) = c • ↑(DirectSum.coeLinearMap ℳ) x) }.toAddHom.toFun) })).symm
def
DirectSum.decomposeLinearEquiv
{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
[DecidableEq ι]
[Semiring R]
[AddCommMonoid M]
[Module R M]
(ℳ : ι → Submodule R M)
[DirectSum.Decomposition ℳ]
:
If M is graded by ι with degree i component ℳ i, then it is isomorphic as
a module to a direct sum of components.
Equations
- One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem
DirectSum.decompose_smul
{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
[DecidableEq ι]
[Semiring R]
[AddCommMonoid M]
[Module R M]
(ℳ : ι → Submodule R M)
[DirectSum.Decomposition ℳ]
(r : R)
(x : M)
:
↑(DirectSum.decompose ℳ) (r • x) = r • ↑(DirectSum.decompose ℳ) x