fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
lmk_apply (s : Finset ι) (x) : (lmk s : _ →ₗ[R] Π₀ i, M i) x = mk s x :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lmk_apply | null |
lsingle_apply (i : ι) (x : M i) : (lsingle i : (M i) →ₗ[R] _) x = single i x :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lsingle_apply | null |
lapply (i : ι) : (Π₀ i, M i) →ₗ[R] M i where
toFun f := f i
map_add' f g := add_apply f g i
map_smul' c f := smul_apply c f i
@[simp] | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lapply | Interpret `fun (f : Π₀ i, M i) ↦ f i` as a linear map. |
lapply_apply (i : ι) (f : Π₀ i, M i) : (lapply i : (Π₀ i, M i) →ₗ[R] _) f = f i :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lapply_apply | null |
injective_pi_lapply : Function.Injective (LinearMap.pi (R := R) <| lapply (M := M)) :=
fun _ _ h ↦ ext fun _ ↦ congr_fun h _
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | injective_pi_lapply | null |
lapply_comp_lsingle_same [DecidableEq ι] (i : ι) :
lapply i ∘ₗ lsingle i = (.id : M i →ₗ[R] M i) := by ext; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lapply_comp_lsingle_same | null |
lapply_comp_lsingle_of_ne [DecidableEq ι] (i i' : ι) (h : i ≠ i') :
lapply i ∘ₗ lsingle i' = (0 : M i' →ₗ[R] M i) := by ext; simp [h.symm] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lapply_comp_lsingle_of_ne | null |
@[simps! apply]
domLCongr (e : ι ≃ ι') : (Π₀ i, M i) ≃ₗ[R] (Π₀ i, M (e.symm i)) where
__ := DFinsupp.equivCongrLeft e
map_add' _ _ := by ext; rfl
map_smul' _ _ := by ext; rfl | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | domLCongr | `DFinsupp.equivCongrLeft` as a linear equivalence.
This is the `DFinsupp` version of `Finsupp.domLCongr`. |
@[simps! apply symm_apply]
sigmaCurryLEquiv {α : ι → Type*} {M : (i : ι) → α i → Type*}
[Π i j, AddCommMonoid (M i j)] [Π i j, Module R (M i j)] [DecidableEq ι] :
(Π₀ (i : (x : ι) × α x), M i.fst i.snd) ≃ₗ[R] Π₀ (i : ι) (j : α i), M i j where
__ := DFinsupp.sigmaCurryEquiv
map_add' _ _ := by ext; rfl
map_smul' _ _ := by ext; rfl | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | sigmaCurryLEquiv | `DFinsupp.sigmaCurryEquiv` as a linear equivalence.
This is the `DFinsupp` version of `Finsupp.finsuppProdLEquiv`. |
@[simps! apply symm_apply]
linearEquivFunOnFintype [Fintype ι] : (Π₀ i, M i) ≃ₗ[R] (Π i, M i) where
__ := equivFunOnFintype
map_add' _ _ := by ext; rfl
map_smul' _ _ := by ext; rfl | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | linearEquivFunOnFintype | `DFinsupp.equivFunOnFintype` as a linear equivalence.
This is the `DFinsupp` version of `Finsupp.linearEquivFunOnFintype`. |
@[simps]
lsum [Semiring S] [Module S N] [SMulCommClass R S N] :
(∀ i, M i →ₗ[R] N) ≃ₗ[S] (Π₀ i, M i) →ₗ[R] N where
toFun F :=
{ toFun := sumAddHom fun i => (F i).toAddMonoidHom
map_add' := (DFinsupp.liftAddHom fun (i : ι) => (F i).toAddMonoidHom).map_add
map_smul' := fun c f => by
dsimp
apply DFinsupp.induction f
· rw [smul_zero, AddMonoidHom.map_zero, smul_zero]
· intro a b f _ _ hf
rw [smul_add, AddMonoidHom.map_add, AddMonoidHom.map_add, smul_add, hf, ← single_smul,
sumAddHom_single, sumAddHom_single, LinearMap.toAddMonoidHom_coe,
LinearMap.map_smul] }
invFun F i := F.comp (lsingle i)
left_inv F := by
ext
simp
right_inv F := by
refine DFinsupp.lhom_ext' (fun i ↦ ?_)
ext
simp
map_add' F G := by
refine DFinsupp.lhom_ext' (fun i ↦ ?_)
ext
simp
map_smul' c F := by
refine DFinsupp.lhom_ext' (fun i ↦ ?_)
ext
simp | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lsum | The `DFinsupp` version of `Finsupp.lsum`.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. |
lsum_single [Semiring S] [Module S N] [SMulCommClass R S N] (F : ∀ i, M i →ₗ[R] N) (i)
(x : M i) : lsum S F (single i x) = F i x := by
simp | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lsum_single | While `simp` can prove this, it is often convenient to avoid unfolding `lsum` into `sumAddHom`
with `DFinsupp.lsum_apply_apply`. |
lsum_lsingle [Semiring S] [∀ i, Module S (M i)] [∀ i, SMulCommClass R S (M i)] :
lsum S (lsingle (R := R) (M := M)) = .id :=
lhom_ext (lsum_single _ _) | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lsum_lsingle | null |
iSup_range_lsingle : ⨆ i, LinearMap.range (lsingle (R := R) (M := M) i) = ⊤ :=
top_le_iff.mp fun m _ ↦ by
rw [← LinearMap.id_apply (R := R) m, ← lsum_lsingle ℕ]
exact dfinsuppSumAddHom_mem _ _ _ fun i _ ↦ Submodule.mem_iSup_of_mem i ⟨_, rfl⟩ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSup_range_lsingle | null |
mker_mapRangeAddMonoidHom (f : ∀ i, β₁ i →+ β₂ i) :
AddMonoidHom.mker (mapRange.addMonoidHom f) =
(AddSubmonoid.pi Set.univ (fun i ↦ AddMonoidHom.mker (f i))).comap coeFnAddMonoidHom := by
ext
simp [AddSubmonoid.pi, DFinsupp.ext_iff] | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mker_mapRangeAddMonoidHom | null |
mrange_mapRangeAddMonoidHom (f : ∀ i, β₁ i →+ β₂ i) :
AddMonoidHom.mrange (mapRange.addMonoidHom f) =
(AddSubmonoid.pi Set.univ (fun i ↦ AddMonoidHom.mrange (f i))).comap coeFnAddMonoidHom := by
classical
ext x
simp only [AddSubmonoid.mem_comap, coeFnAddMonoidHom_apply]
refine ⟨fun ⟨y, hy⟩ i hi ↦ ?_, fun h ↦ ?_⟩
· simp [← hy]
· choose g hg using fun i => h i (Set.mem_univ _)
use DFinsupp.mk x.support (g ·)
ext i
simp only [Finset.coe_sort_coe, mapRange.addMonoidHom_apply, mapRange_apply]
by_cases mem : i ∈ x.support
· rw [mk_of_mem mem, hg]
· rw [DFinsupp.notMem_support_iff.mp mem, mk_of_notMem mem, map_zero] | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mrange_mapRangeAddMonoidHom | null |
mapRange_smul (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) (r : R)
(hf' : ∀ i x, f i (r • x) = r • f i x) (g : Π₀ i, β₁ i) :
mapRange f hf (r • g) = r • mapRange f hf g := by
ext
simp only [mapRange_apply f, coe_smul, Pi.smul_apply, hf'] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange_smul | null |
@[simps! apply]
mapRange.linearMap (f : ∀ i, β₁ i →ₗ[R] β₂ i) : (Π₀ i, β₁ i) →ₗ[R] Π₀ i, β₂ i :=
{ mapRange.addMonoidHom fun i => (f i).toAddMonoidHom with
toFun := mapRange (fun i x => f i x) fun i => (f i).map_zero
map_smul' := fun r => mapRange_smul _ (fun i => (f i).map_zero) _ fun i => (f i).map_smul r }
@[simp] | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearMap | `DFinsupp.mapRange` as a `LinearMap`. |
mapRange.linearMap_id :
(mapRange.linearMap fun i => (LinearMap.id : β₂ i →ₗ[R] _)) = LinearMap.id := by
ext
simp [linearMap] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearMap_id | null |
mapRange.linearMap_comp (f : ∀ i, β₁ i →ₗ[R] β₂ i) (f₂ : ∀ i, β i →ₗ[R] β₁ i) :
(mapRange.linearMap fun i => (f i).comp (f₂ i)) =
(mapRange.linearMap f).comp (mapRange.linearMap f₂) :=
LinearMap.ext <| mapRange_comp (fun i x => f i x) (fun i x => f₂ i x)
(fun i => (f i).map_zero) (fun i => (f₂ i).map_zero) (by simp) | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearMap_comp | null |
sum_mapRange_index.linearMap [DecidableEq ι] {f : ∀ i, β₁ i →ₗ[R] β₂ i}
{h : ∀ i, β₂ i →ₗ[R] N} {l : Π₀ i, β₁ i} :
DFinsupp.lsum ℕ h (mapRange.linearMap f l) = DFinsupp.lsum ℕ (fun i => (h i).comp (f i)) l := by
classical simpa [DFinsupp.sumAddHom_apply] using sum_mapRange_index fun i => by simp | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | sum_mapRange_index.linearMap | null |
ker_mapRangeLinearMap (f : ∀ i, β₁ i →ₗ[R] β₂ i) :
LinearMap.ker (mapRange.linearMap f) =
(Submodule.pi Set.univ (fun i ↦ LinearMap.ker (f i))).comap (coeFnLinearMap R) :=
Submodule.toAddSubmonoid_injective <| mker_mapRangeAddMonoidHom (f · |>.toAddMonoidHom) | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | ker_mapRangeLinearMap | null |
range_mapRangeLinearMap (f : ∀ i, β₁ i →ₗ[R] β₂ i) :
LinearMap.range (mapRange.linearMap f) =
(Submodule.pi Set.univ (LinearMap.range <| f ·)).comap (coeFnLinearMap R) :=
Submodule.toAddSubmonoid_injective <| mrange_mapRangeAddMonoidHom (f · |>.toAddMonoidHom) | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | range_mapRangeLinearMap | null |
@[simps apply]
mapRange.linearEquiv (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) : (Π₀ i, β₁ i) ≃ₗ[R] Π₀ i, β₂ i :=
{ mapRange.addEquiv fun i => (e i).toAddEquiv,
mapRange.linearMap fun i => (e i).toLinearMap with
toFun := mapRange (fun i x => e i x) fun i => (e i).map_zero
invFun := mapRange (fun i x => (e i).symm x) fun i => (e i).symm.map_zero }
@[simp] | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearEquiv | `DFinsupp.mapRange.linearMap` as a `LinearEquiv`. |
mapRange.linearEquiv_refl :
(mapRange.linearEquiv fun i => LinearEquiv.refl R (β₁ i)) = LinearEquiv.refl _ _ :=
LinearEquiv.ext mapRange_id | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearEquiv_refl | null |
mapRange.linearEquiv_trans (f : ∀ i, β i ≃ₗ[R] β₁ i) (f₂ : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
(mapRange.linearEquiv fun i => (f i).trans (f₂ i)) =
(mapRange.linearEquiv f).trans (mapRange.linearEquiv f₂) :=
LinearEquiv.ext <| mapRange_comp (fun i x => f₂ i x) (fun i x => f i x)
(fun i => (f₂ i).map_zero) (fun i => (f i).map_zero) (by simp)
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearEquiv_trans | null |
mapRange.linearEquiv_symm (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
(mapRange.linearEquiv e).symm = mapRange.linearEquiv fun i => (e i).symm :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mapRange.linearEquiv_symm | null |
ker_mapRangeAddMonoidHom
[∀ i, AddCommGroup (β₁ i)] [∀ i, AddCommMonoid (β₂ i)] (f : ∀ i, β₁ i →+ β₂ i) :
(mapRange.addMonoidHom f).ker =
(AddSubgroup.pi Set.univ (f · |>.ker)).comap coeFnAddMonoidHom :=
AddSubgroup.toAddSubmonoid_injective <| mker_mapRangeAddMonoidHom f | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | ker_mapRangeAddMonoidHom | null |
range_mapRangeAddMonoidHom
[∀ i, AddCommGroup (β₁ i)] [∀ i, AddCommGroup (β₂ i)] (f : ∀ i, β₂ i →+ β₁ i) :
(mapRange.addMonoidHom f).range =
(AddSubgroup.pi Set.univ (f · |>.range)).comap coeFnAddMonoidHom :=
AddSubgroup.toAddSubmonoid_injective <| mrange_mapRangeAddMonoidHom f | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | range_mapRangeAddMonoidHom | null |
coprodMap (f : ∀ i : ι, M i →ₗ[R] N) : (Π₀ i, M i) →ₗ[R] N :=
(DFinsupp.lsum ℕ fun _ : ι => LinearMap.id) ∘ₗ DFinsupp.mapRange.linearMap f | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | coprodMap | Given a family of linear maps `f i : M i →ₗ[R] N`, we can form a linear map
`(Π₀ i, M i) →ₗ[R] N` which sends `x : Π₀ i, M i` to the sum over `i` of `f i` applied to `x i`.
This is the map coming from the universal property of `Π₀ i, M i` as the coproduct of the `M i`.
See also `LinearMap.coprod` for the binary product version. |
coprodMap_apply [∀ x : N, Decidable (x ≠ 0)] (f : ∀ i : ι, M i →ₗ[R] N) (x : Π₀ i, M i) :
coprodMap f x =
DFinsupp.sum (mapRange (fun i => f i) (fun _ => LinearMap.map_zero _) x) fun _ =>
id :=
DFinsupp.sumAddHom_apply _ _ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | coprodMap_apply | null |
coprodMap_apply_single (f : ∀ i : ι, M i →ₗ[R] N) (i : ι) (x : M i) :
coprodMap f (single i x) = f i x := by
simp [coprodMap] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | coprodMap_apply_single | null |
dfinsuppSum_mem {β : ι → Type*} [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
(S : Submodule R N) (f : Π₀ i, β i) (g : ∀ i, β i → N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) :
f.sum g ∈ S :=
_root_.dfinsuppSum_mem S f g h
@[deprecated (since := "2025-04-06")] alias dfinsupp_sum_mem := dfinsuppSum_mem | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | dfinsuppSum_mem | null |
dfinsuppSumAddHom_mem {β : ι → Type*} [∀ i, AddZeroClass (β i)] (S : Submodule R N)
(f : Π₀ i, β i) (g : ∀ i, β i →+ N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) :
DFinsupp.sumAddHom g f ∈ S :=
_root_.dfinsuppSumAddHom_mem S f g h
@[deprecated (since := "2025-04-06")] alias dfinsupp_sumAddHom_mem := dfinsuppSumAddHom_mem | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | dfinsuppSumAddHom_mem | null |
iSup_eq_range_dfinsupp_lsum (p : ι → Submodule R N) :
iSup p = LinearMap.range (DFinsupp.lsum ℕ fun i => (p i).subtype) := by
apply le_antisymm
· apply iSup_le _
intro i y hy
simp only [LinearMap.mem_range, lsum_apply_apply]
exact ⟨DFinsupp.single i ⟨y, hy⟩, DFinsupp.sumAddHom_single _ _ _⟩
· rintro x ⟨v, rfl⟩
exact dfinsuppSumAddHom_mem _ v _ fun i _ => (le_iSup p i : p i ≤ _) (v i).2 | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSup_eq_range_dfinsupp_lsum | The supremum of a family of submodules is equal to the range of `DFinsupp.lsum`; that is
every element in the `iSup` can be produced from taking a finite number of non-zero elements
of `p i`, coercing them to `N`, and summing them. |
biSup_eq_range_dfinsupp_lsum (p : ι → Prop) [DecidablePred p] (S : ι → Submodule R N) :
⨆ (i) (_ : p i), S i =
LinearMap.range
(LinearMap.comp
(DFinsupp.lsum ℕ (fun i => (S i).subtype))
(DFinsupp.filterLinearMap R _ p)) := by
apply le_antisymm
· refine iSup₂_le fun i hi y hy => ⟨DFinsupp.single i ⟨y, hy⟩, ?_⟩
rw [LinearMap.comp_apply, filterLinearMap_apply, filter_single_pos _ _ hi]
simp only [lsum_apply_apply, sumAddHom_single, LinearMap.toAddMonoidHom_coe, coe_subtype]
· rintro x ⟨v, rfl⟩
refine dfinsuppSumAddHom_mem _ _ _ fun i _ => ?_
refine mem_iSup_of_mem i ?_
by_cases hp : p i
· simp [hp]
· simp [hp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | biSup_eq_range_dfinsupp_lsum | The bounded supremum of a family of commutative additive submonoids is equal to the range of
`DFinsupp.sumAddHom` composed with `DFinsupp.filter_add_monoid_hom`; that is, every element in the
bounded `iSup` can be produced from taking a finite number of non-zero elements from the `S i` that
satisfy `p i`, coercing them to `γ`, and summing them. |
mem_iSup_iff_exists_dfinsupp (p : ι → Submodule R N) (x : N) :
x ∈ iSup p ↔
∃ f : Π₀ i, p i, DFinsupp.lsum ℕ (fun i => (p i).subtype) f = x :=
SetLike.ext_iff.mp (iSup_eq_range_dfinsupp_lsum p) x | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mem_iSup_iff_exists_dfinsupp | A characterisation of the span of a family of submodules.
See also `Submodule.mem_iSup_iff_exists_finsupp`. |
mem_iSup_iff_exists_dfinsupp' (p : ι → Submodule R N) [∀ (i) (x : p i), Decidable (x ≠ 0)]
(x : N) : x ∈ iSup p ↔ ∃ f : Π₀ i, p i, (f.sum fun _ xi => ↑xi) = x := by
rw [mem_iSup_iff_exists_dfinsupp]
simp_rw [DFinsupp.lsum_apply_apply, DFinsupp.sumAddHom_apply,
LinearMap.toAddMonoidHom_coe, coe_subtype] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mem_iSup_iff_exists_dfinsupp' | A variant of `Submodule.mem_iSup_iff_exists_dfinsupp` with the RHS fully unfolded.
See also `Submodule.mem_iSup_iff_exists_finsupp`. |
mem_biSup_iff_exists_dfinsupp (p : ι → Prop) [DecidablePred p] (S : ι → Submodule R N)
(x : N) :
(x ∈ ⨆ (i) (_ : p i), S i) ↔
∃ f : Π₀ i, S i,
DFinsupp.lsum ℕ (fun i => (S i).subtype) (f.filter p) = x :=
SetLike.ext_iff.mp (biSup_eq_range_dfinsupp_lsum p S) x | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mem_biSup_iff_exists_dfinsupp | null |
mem_iSup_iff_exists_finsupp (p : ι → Submodule R N) (x : N) :
x ∈ iSup p ↔ ∃ (f : ι →₀ N), (∀ i, f i ∈ p i) ∧ (f.sum fun _i xi ↦ xi) = x := by
classical
rw [mem_iSup_iff_exists_dfinsupp']
refine ⟨fun ⟨f, hf⟩ ↦ ⟨⟨f.support, fun i ↦ (f i : N), by simp⟩, by simp, hf⟩, ?_⟩
rintro ⟨f, hf, rfl⟩
refine ⟨DFinsupp.mk f.support fun i ↦ ⟨f i, hf i⟩, Finset.sum_congr ?_ fun i hi ↦ ?_⟩
· ext; simp [mk_eq_zero]
· simp [Finsupp.mem_support_iff.mp hi] | lemma | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mem_iSup_iff_exists_finsupp | null |
mem_iSup_finset_iff_exists_sum {s : Finset ι} (p : ι → Submodule R N) (a : N) :
(a ∈ ⨆ i ∈ s, p i) ↔ ∃ μ : ∀ i, p i, (∑ i ∈ s, (μ i : N)) = a := by
classical
rw [Submodule.mem_iSup_iff_exists_dfinsupp']
constructor <;> rintro ⟨μ, hμ⟩
· use fun i => ⟨μ i, (iSup_const_le : _ ≤ p i) (coe_mem <| μ i)⟩
rw [← hμ]
symm
apply Finset.sum_subset
· intro x
contrapose
intro hx
rw [mem_support_iff, not_ne_iff]
ext
rw [coe_zero, ← mem_bot R]
suffices ⊥ = ⨆ (_ : x ∈ s), p x from this.symm ▸ coe_mem (μ x)
exact (iSup_neg hx).symm
· intro x _ hx
rw [mem_support_iff, not_ne_iff] at hx
rw [hx]
rfl
· refine ⟨DFinsupp.mk s ?_, ?_⟩
· rintro ⟨i, hi⟩
refine ⟨μ i, ?_⟩
rw [iSup_pos]
· exact coe_mem _
· exact hi
simp only [DFinsupp.sum]
rw [Finset.sum_subset support_mk_subset, ← hμ]
· exact Finset.sum_congr rfl fun x hx => by rw [mk_of_mem hx]
· intro x _ hx
rw [mem_support_iff, not_ne_iff] at hx
rw [hx]
rfl | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | mem_iSup_finset_iff_exists_sum | null |
iSupIndep_iff_forall_dfinsupp (p : ι → Submodule R N) :
iSupIndep p ↔
∀ (i) (x : p i) (v : Π₀ i : ι, ↥(p i)),
lsum ℕ (fun i => (p i).subtype) (erase i v) = x → x = 0 := by
simp_rw [iSupIndep_def, Submodule.disjoint_def,
Submodule.mem_biSup_iff_exists_dfinsupp, exists_imp, filter_ne_eq_erase]
refine forall_congr' fun i => Subtype.forall'.trans ?_
simp_rw [Submodule.coe_eq_zero]
/- If `DFinsupp.lsum` applied with `Submodule.subtype` is injective then the submodules are
iSupIndep. -/ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_iff_forall_dfinsupp | Independence of a family of submodules can be expressed as a quantifier over `DFinsupp`s.
This is an intermediate result used to prove
`iSupIndep_of_dfinsupp_lsum_injective` and
`iSupIndep.dfinsupp_lsum_injective`. |
iSupIndep_of_dfinsupp_lsum_injective (p : ι → Submodule R N)
(h : Function.Injective (lsum ℕ fun i => (p i).subtype)) :
iSupIndep p := by
rw [iSupIndep_iff_forall_dfinsupp]
intro i x v hv
replace hv : lsum ℕ (fun i => (p i).subtype) (erase i v) =
lsum ℕ (fun i => (p i).subtype) (single i x) := by
simpa only [lsum_single] using hv
have := DFunLike.ext_iff.mp (h hv) i
simpa [eq_comm] using this
/- If `DFinsupp.sumAddHom` applied with `AddSubmonoid.subtype` is injective then the additive
submonoids are independent. -/ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_of_dfinsupp_lsum_injective | null |
iSupIndep_of_dfinsuppSumAddHom_injective (p : ι → AddSubmonoid N)
(h : Function.Injective (sumAddHom fun i => (p i).subtype)) : iSupIndep p := by
rw [← iSupIndep_map_orderIso_iff (AddSubmonoid.toNatSubmodule : AddSubmonoid N ≃o _)]
exact iSupIndep_of_dfinsupp_lsum_injective _ h
@[deprecated (since := "2025-04-06")]
alias iSupIndep_of_dfinsupp_sumAddHom_injective := iSupIndep_of_dfinsuppSumAddHom_injective | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_of_dfinsuppSumAddHom_injective | null |
lsum_comp_mapRange_toSpanSingleton [∀ m : R, Decidable (m ≠ 0)] (p : ι → Submodule R N)
{v : ι → N} (hv : ∀ i : ι, v i ∈ p i) :
(lsum ℕ fun i => (p i).subtype : _ →ₗ[R] _).comp
((mapRange.linearMap fun i => LinearMap.toSpanSingleton R (↥(p i)) ⟨v i, hv i⟩ :
_ →ₗ[R] _).comp
(finsuppLequivDFinsupp R : (ι →₀ R) ≃ₗ[R] _).toLinearMap) =
Finsupp.linearCombination R v := by
ext
simp | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | lsum_comp_mapRange_toSpanSingleton | Combining `DFinsupp.lsum` with `LinearMap.toSpanSingleton` is the same as
`Finsupp.linearCombination` |
iSupIndep_of_dfinsuppSumAddHom_injective' (p : ι → AddSubgroup N)
(h : Function.Injective (sumAddHom fun i => (p i).subtype)) : iSupIndep p := by
rw [← iSupIndep_map_orderIso_iff (AddSubgroup.toIntSubmodule : AddSubgroup N ≃o _)]
exact iSupIndep_of_dfinsupp_lsum_injective _ h
@[deprecated (since := "2025-04-06")]
alias iSupIndep_of_dfinsupp_sumAddHom_injective' := iSupIndep_of_dfinsuppSumAddHom_injective' | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_of_dfinsuppSumAddHom_injective' | If `DFinsupp.sumAddHom` applied with `AddSubmonoid.subtype` is injective then the additive
subgroups are independent. |
iSupIndep.dfinsupp_lsum_injective {p : ι → Submodule R N} (h : iSupIndep p) :
Function.Injective (lsum ℕ fun i => (p i).subtype) := by
rw [iSupIndep_iff_forall_dfinsupp] at h
suffices LinearMap.ker (lsum ℕ fun i => (p i).subtype) = ⊥ by
letI thisI : AddCommGroup (Π₀ i, p i) := inferInstance
rw [LinearMap.ker_eq_bot] at this
exact this
rw [LinearMap.ker_eq_bot']
intro m hm
ext i : 1
rw [DFinsupp.zero_apply, ← neg_eq_zero]
refine h i (-m i) m ?_
rwa [← erase_add_single i m, LinearMap.map_add, lsum_single, Submodule.subtype_apply,
add_eq_zero_iff_eq_neg, ← Submodule.coe_neg] at hm | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep.dfinsupp_lsum_injective | The canonical map out of a direct sum of a family of submodules is injective when the submodules
are `iSupIndep`.
Note that this is not generally true for `[Semiring R]`, for instance when `A` is the
`ℕ`-submodules of the positive and negative integers.
See `Counterexamples/DirectSumIsInternal.lean` for a proof of this fact. |
iSupIndep.dfinsuppSumAddHom_injective {p : ι → AddSubgroup N} (h : iSupIndep p) :
Function.Injective (sumAddHom fun i => (p i).subtype) := by
rw [← iSupIndep_map_orderIso_iff (AddSubgroup.toIntSubmodule : AddSubgroup N ≃o _)] at h
exact h.dfinsupp_lsum_injective
@[deprecated (since := "2025-04-06")]
alias iSupIndep.dfinsupp_sumAddHom_injective := iSupIndep.dfinsuppSumAddHom_injective | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep.dfinsuppSumAddHom_injective | The canonical map out of a direct sum of a family of additive subgroups is injective when the
additive subgroups are `iSupIndep`. |
iSupIndep_iff_dfinsupp_lsum_injective (p : ι → Submodule R N) :
iSupIndep p ↔ Function.Injective (lsum ℕ fun i => (p i).subtype) :=
⟨iSupIndep.dfinsupp_lsum_injective, iSupIndep_of_dfinsupp_lsum_injective p⟩ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_iff_dfinsupp_lsum_injective | A family of submodules over an additive group are independent if and only iff `DFinsupp.lsum`
applied with `Submodule.subtype` is injective.
Note that this is not generally true for `[Semiring R]`; see
`iSupIndep.dfinsupp_lsum_injective` for details. |
iSupIndep_iff_dfinsuppSumAddHom_injective (p : ι → AddSubgroup N) :
iSupIndep p ↔ Function.Injective (sumAddHom fun i => (p i).subtype) :=
⟨iSupIndep.dfinsuppSumAddHom_injective, iSupIndep_of_dfinsuppSumAddHom_injective' p⟩
@[deprecated (since := "2025-04-06")]
alias iSupIndep_iff_dfinsupp_sumAddHom_injective := iSupIndep_iff_dfinsuppSumAddHom_injective | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_iff_dfinsuppSumAddHom_injective | A family of additive subgroups over an additive group are independent if and only if
`DFinsupp.sumAddHom` applied with `AddSubgroup.subtype` is injective. |
@[simps! apply] noncomputable iSupIndep.linearEquiv {p : ι → Submodule R N} (ind : iSupIndep p)
(iSup_top : ⨆ i, p i = ⊤) : (Π₀ i, p i) ≃ₗ[R] N :=
.ofBijective _ ⟨ind.dfinsupp_lsum_injective, by
rwa [← LinearMap.range_eq_top, ← Submodule.iSup_eq_range_dfinsupp_lsum]⟩ | def | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep.linearEquiv | If `(pᵢ)ᵢ` is a family of independent submodules that generates the whole module `N`, then
`N` is isomorphic to the direct sum of the submodules. |
iSupIndep.linearEquiv_symm_apply {p : ι → Submodule R N} (ind : iSupIndep p)
(iSup_top : ⨆ i, p i = ⊤) {i : ι} {x : N} (h : x ∈ p i) :
(ind.linearEquiv iSup_top).symm x = .single i ⟨x, h⟩ := by
simp [← LinearEquiv.eq_symm_apply, iSupIndep.linearEquiv] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep.linearEquiv_symm_apply | null |
iSupIndep.linearIndependent [NoZeroSMulDivisors R N] {ι} (p : ι → Submodule R N)
(hp : iSupIndep p) {v : ι → N} (hv : ∀ i, v i ∈ p i) (hv' : ∀ i, v i ≠ 0) :
LinearIndependent R v := by
let _ := Classical.decEq ι
let _ := Classical.decEq R
rw [linearIndependent_iff]
intro l hl
let a :=
DFinsupp.mapRange.linearMap (fun i => LinearMap.toSpanSingleton R (p i) ⟨v i, hv i⟩)
l.toDFinsupp
have ha : a = 0 := by
apply hp.dfinsupp_lsum_injective
rwa [← lsum_comp_mapRange_toSpanSingleton _ hv] at hl
ext i
apply smul_left_injective R (hv' i)
have : l i • v i = a i := rfl
simp only [coe_zero, Pi.zero_apply, ZeroMemClass.coe_zero, smul_eq_zero, ha] at this
simpa | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep.linearIndependent | If a family of submodules is independent, then a choice of nonzero vector from each submodule
forms a linearly independent family.
See also `iSupIndep.linearIndependent'`. |
iSupIndep_iff_linearIndependent_of_ne_zero [NoZeroSMulDivisors R N] {ι} {v : ι → N}
(h_ne_zero : ∀ i, v i ≠ 0) : (iSupIndep fun i => R ∙ v i) ↔ LinearIndependent R v :=
let _ := Classical.decEq ι
⟨fun hv => hv.linearIndependent _ (fun i => Submodule.mem_span_singleton_self <| v i) h_ne_zero,
fun hv => hv.iSupIndep_span_singleton⟩ | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | iSupIndep_iff_linearIndependent_of_ne_zero | null |
coe_dfinsuppSum (t : Π₀ i, γ i) (g : ∀ i, γ i → M →ₛₗ[σ₁₂] M₂) :
⇑(t.sum g) = t.sum fun i d => g i d := rfl
@[deprecated (since := "2025-04-06")] alias coe_dfinsupp_sum := coe_dfinsuppSum
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | coe_dfinsuppSum | null |
dfinsuppSum_apply (t : Π₀ i, γ i) (g : ∀ i, γ i → M →ₛₗ[σ₁₂] M₂) (b : M) :
(t.sum g) b = t.sum fun i d => g i d b :=
sum_apply _ _ _
@[deprecated (since := "2025-04-06")] alias dfinsupp_sum_apply := dfinsuppSum_apply | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | dfinsuppSum_apply | null |
@[simp]
map_dfinsuppSumAddHom (f : M →ₛₗ[σ₁₂] M₂) {t : Π₀ i, γ i} {g : ∀ i, γ i →+ M} :
f (sumAddHom g t) = sumAddHom (fun i => f.toAddMonoidHom.comp (g i)) t :=
f.toAddMonoidHom.map_dfinsuppSumAddHom _ _
@[deprecated (since := "2025-04-06")] alias map_dfinsupp_sumAddHom := map_dfinsuppSumAddHom | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | map_dfinsuppSumAddHom | null |
@[simp]
map_dfinsuppSumAddHom [∀ i, AddZeroClass (γ i)] (f : M ≃ₛₗ[τ₁₂] M₂) (t : Π₀ i, γ i)
(g : ∀ i, γ i →+ M) :
f (sumAddHom g t) = sumAddHom (fun i => f.toAddEquiv.toAddMonoidHom.comp (g i)) t :=
f.toAddEquiv.map_dfinsuppSumAddHom _ _
@[deprecated (since := "2025-04-06")] alias map_dfinsupp_sumAddHom := map_dfinsuppSumAddHom | theorem | LinearAlgebra | [
"Mathlib.Data.DFinsupp.Submonoid",
"Mathlib.Data.DFinsupp.Sigma",
"Mathlib.Data.Finsupp.ToDFinsupp",
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.LinearAlgebra.LinearIndependent.Lemmas"
] | Mathlib/LinearAlgebra/DFinsupp.lean | map_dfinsuppSumAddHom | null |
LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo
{R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
{Φ : Set M} (hΦ₁ : Φ.Finite) (hΦ₂ : span R Φ = ⊤) {e : M ≃ₗ[R] M} (he : MapsTo e Φ Φ) :
IsOfFinOrder e := by
replace he : BijOn e Φ Φ := (hΦ₁.injOn_iff_bijOn_of_mapsTo he).mp e.injective.injOn
let e' := he.equiv
have : Finite Φ := finite_coe_iff.mpr hΦ₁
obtain ⟨k, hk₀, hk⟩ := isOfFinOrder_of_finite e'
refine ⟨k, hk₀, ?_⟩
ext m
have hm : m ∈ span R Φ := hΦ₂ ▸ Submodule.mem_top
simp only [mul_left_iterate, mul_one, LinearEquiv.coe_one, id_eq]
refine Submodule.span_induction (fun x hx ↦ ?_) (by simp)
(fun x y _ _ hx hy ↦ by simp [map_add, hx, hy]) (fun t x _ hx ↦ by simp [hx]) hm
rw [LinearEquiv.pow_apply, ← he.1.coe_iterate_restrict ⟨x, hx⟩ k]
replace hk : (e') ^ k = 1 := by simpa [IsPeriodicPt, IsFixedPt] using hk
replace hk := Equiv.congr_fun hk ⟨x, hx⟩
rwa [Equiv.Perm.coe_one, id_eq, Subtype.ext_iff, Equiv.Perm.coe_pow] at hk | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.LinearAlgebra.Span.Defs",
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/FiniteSpan.lean | LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo | A linear equivalence which preserves a finite spanning set must have finite order. |
noncomputable basisFreeMonoid : Basis (FreeMonoid X) R (FreeAlgebra R X) :=
Finsupp.basisSingleOne.map (equivMonoidAlgebraFreeMonoid (R := R) (X := X)).symm.toLinearEquiv | def | LinearAlgebra | [
"Mathlib.Algebra.FreeAlgebra",
"Mathlib.LinearAlgebra.Basis.Cardinality",
"Mathlib.LinearAlgebra.Dimension.StrongRankCondition",
"Mathlib.LinearAlgebra.Dimension.Subsingleton",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.FreeModule.Strong... | Mathlib/LinearAlgebra/FreeAlgebra.lean | basisFreeMonoid | null |
rank_eq [CommRing R] [Nontrivial R] :
Module.rank R (FreeAlgebra R X) = Cardinal.lift.{u} (Cardinal.mk (List X)) := by
rw [← (Basis.mk_eq_rank'.{_,_,_,u} (basisFreeMonoid R X)).trans (Cardinal.lift_id _),
Cardinal.lift_umax.{v, u}, FreeMonoid] | theorem | LinearAlgebra | [
"Mathlib.Algebra.FreeAlgebra",
"Mathlib.LinearAlgebra.Basis.Cardinality",
"Mathlib.LinearAlgebra.Dimension.StrongRankCondition",
"Mathlib.LinearAlgebra.Dimension.Subsingleton",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.FreeModule.Strong... | Mathlib/LinearAlgebra/FreeAlgebra.lean | rank_eq | null |
Algebra.rank_adjoin_le {R : Type u} {S : Type v} [CommRing R] [Ring S] [Algebra R S]
(s : Set S) : Module.rank R (adjoin R s) ≤ max #s ℵ₀ := by
rw [adjoin_eq_range_freeAlgebra_lift]
cases subsingleton_or_nontrivial R
· rw [rank_subsingleton]; exact one_le_aleph0.trans (le_max_right _ _)
rw [← lift_le.{max u v}]
refine (lift_rank_range_le (FreeAlgebra.lift R ((↑) : s → S)).toLinearMap).trans ?_
rw [FreeAlgebra.rank_eq, lift_id'.{v,u}, lift_umax.{v,u}, lift_le, max_comm]
exact mk_list_le_max _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.FreeAlgebra",
"Mathlib.LinearAlgebra.Basis.Cardinality",
"Mathlib.LinearAlgebra.Dimension.StrongRankCondition",
"Mathlib.LinearAlgebra.Dimension.Subsingleton",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.FreeModule.Strong... | Mathlib/LinearAlgebra/FreeAlgebra.lean | Algebra.rank_adjoin_le | null |
GeneralLinearGroup :=
(M →ₗ[R] M)ˣ | abbrev | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | GeneralLinearGroup | The group of invertible linear maps from `M` to itself |
toLinearEquiv (f : GeneralLinearGroup R M) : M ≃ₗ[R] M :=
{ f.val with
invFun := f.inv.toFun
left_inv := fun m ↦ show (f.inv * f.val) m = m by simp
right_inv := fun m ↦ show (f.val * f.inv) m = m by simp }
@[simp] lemma coe_toLinearEquiv (f : GeneralLinearGroup R M) :
f.toLinearEquiv = (f : M → M) := rfl | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | toLinearEquiv | An invertible linear map `f` determines an equivalence from `M` to itself. |
ofLinearEquiv (f : M ≃ₗ[R] M) : GeneralLinearGroup R M where
val := f
inv := (f.symm : M →ₗ[R] M)
val_inv := LinearMap.ext fun _ ↦ f.apply_symm_apply _
inv_val := LinearMap.ext fun _ ↦ f.symm_apply_apply _
@[simp] lemma coe_ofLinearEquiv (f : M ≃ₗ[R] M) :
ofLinearEquiv f = (f : M → M) := rfl
variable (R M) in | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | ofLinearEquiv | An equivalence from `M` to itself determines an invertible linear map. |
generalLinearEquiv : GeneralLinearGroup R M ≃* M ≃ₗ[R] M where
toFun := toLinearEquiv
invFun := ofLinearEquiv
map_mul' x y := by ext; rfl
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | generalLinearEquiv | The general linear group on `R` and `M` is multiplicatively equivalent to the type of linear
equivalences between `M` and itself. |
generalLinearEquiv_to_linearMap (f : GeneralLinearGroup R M) :
(generalLinearEquiv R M f : M →ₗ[R] M) = f := by ext; rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | generalLinearEquiv_to_linearMap | null |
coeFn_generalLinearEquiv (f : GeneralLinearGroup R M) :
(generalLinearEquiv R M f) = (f : M → M) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | coeFn_generalLinearEquiv | null |
congrLinearEquiv (e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂) :
GeneralLinearGroup R₁ M₁ ≃* GeneralLinearGroup R₂ M₂ :=
Units.mapEquiv (LinearEquiv.conjRingEquiv e₁₂).toMulEquiv
@[simp] lemma congrLinearEquiv_apply (e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂) (g : GeneralLinearGroup R₁ M₁) :
congrLinearEquiv e₁₂ g = ofLinearEquiv (e₁₂.symm.trans <| g.toLinearEquiv.trans e₁₂) :=
rfl
@[simp] lemma congrLinearEquiv_symm (e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂) :
(congrLinearEquiv e₁₂).symm = congrLinearEquiv e₁₂.symm :=
rfl
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | congrLinearEquiv | A semilinear equivalence from `V` to `W` determines an isomorphism of general linear
groups. |
congrLinearEquiv_trans
{N₁ N₂ N₃ : Type*} [AddCommMonoid N₁] [AddCommMonoid N₂] [AddCommMonoid N₃]
[Module R N₁] [Module R N₂] [Module R N₃] (e₁₂ : N₁ ≃ₗ[R] N₂) (e₂₃ : N₂ ≃ₗ[R] N₃) :
(congrLinearEquiv e₁₂).trans (congrLinearEquiv e₂₃) = congrLinearEquiv (e₁₂.trans e₂₃) :=
rfl | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | congrLinearEquiv_trans | null |
congrLinearEquiv_trans' (e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂) (e₂₃ : M₂ ≃ₛₗ[σ₂₃] M₃) :
(congrLinearEquiv e₁₂).trans (congrLinearEquiv e₂₃) =
congrLinearEquiv (e₁₂.trans e₂₃) :=
rfl
@[simp] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | congrLinearEquiv_trans' | Stronger form of `congrLinearEquiv.trans` applying to semilinear maps. Not a simp lemma as
`σ₁₃` and `σ₃₁` cannot be inferred from the LHS. |
congrLinearEquiv_refl :
congrLinearEquiv (LinearEquiv.refl R₁ M₁) = MulEquiv.refl (GeneralLinearGroup R₁ M₁) :=
rfl | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Equiv.Basic"
] | Mathlib/LinearAlgebra/GeneralLinearGroup.lean | congrLinearEquiv_refl | null |
goursatFst : Submodule R M :=
(LinearMap.ker <| (LinearMap.snd R M N).comp L.subtype).map ((LinearMap.fst R M N).comp L.subtype)
variable (L) in | def | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursatFst | For `L` a submodule of `M × N`, `L.goursatFst` is the kernel of the projection map `L → N`,
considered as a submodule of `M`.
This is the first submodule appearing in Goursat's lemma. See `Subgroup.goursat`. |
goursatSnd : Submodule R N :=
(LinearMap.ker <| (LinearMap.fst R M N).comp L.subtype).map ((LinearMap.snd R M N).comp L.subtype) | def | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursatSnd | For `L` a subgroup of `M × N`, `L.goursatSnd` is the kernel of the projection map `L → M`,
considered as a subgroup of `N`.
This is the second subgroup appearing in Goursat's lemma. See `Subgroup.goursat`. |
goursatFst_toAddSubgroup :
(goursatFst L).toAddSubgroup = L.toAddSubgroup.goursatFst := by
ext x
simp [mem_toAddSubgroup, goursatFst, AddSubgroup.mem_goursatFst] | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursatFst_toAddSubgroup | null |
goursatSnd_toAddSubgroup :
(goursatSnd L).toAddSubgroup = L.toAddSubgroup.goursatSnd := by
ext x
simp [mem_toAddSubgroup, goursatSnd, AddSubgroup.mem_goursatSnd]
variable (L) in | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursatSnd_toAddSubgroup | null |
goursatFst_prod_goursatSnd_le : L.goursatFst.prod L.goursatSnd ≤ L := by
simpa only [← toAddSubgroup_le, goursatFst_toAddSubgroup, goursatSnd_toAddSubgroup]
using L.toAddSubgroup.goursatFst_prod_goursatSnd_le
include hL₁ hL₂ in | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursatFst_prod_goursatSnd_le | null |
goursat_surjective : ∃ e : (M ⧸ L.goursatFst) ≃ₗ[R] N ⧸ L.goursatSnd,
LinearMap.range ((L.goursatFst.mkQ.prodMap L.goursatSnd.mkQ).comp L.subtype) = e.graph := by
obtain ⟨(e : M ⧸ L.goursatFst ≃+ N ⧸ L.goursatSnd), he⟩ :=
L.toAddSubgroup.goursat_surjective hL₁ hL₂
have (r : R) (x : M ⧸ L.goursatFst) : e (r • x) = r • e x := by
change (r • x, r • e x) ∈ e.toAddMonoidHom.graph
rw [← he, ← Prod.smul_mk]
have : (x, e x) ∈ e.toAddMonoidHom.graph := rfl
rw [← he, AddMonoidHom.mem_range] at this
rcases this with ⟨⟨l, hl⟩, hl'⟩
use ⟨r • l, L.smul_mem r hl⟩
rw [← hl']
rfl
use { e with map_smul' := this }
rw [← toAddSubgroup_injective.eq_iff]
convert he using 1
ext v
rw [mem_toAddSubgroup, mem_graph_iff, Eq.comm]
rfl | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursat_surjective | **Goursat's lemma** for a submodule of a product with surjective projections.
If `L` is a submodule of `M × N` which projects fully on both factors, then there exist submodules
`M' ≤ M` and `N' ≤ N` such that `M' × N' ≤ L` and the image of `L` in `(M ⧸ M') × (N ⧸ N')` is the
graph of an isomorphism of `R`-modules `(M ⧸ M') ≃ (N ⧸ N')`.
`M` and `N` can be explicitly constructed as `L.goursatFst` and `L.goursatSnd` respectively. |
goursat : ∃ (M' : Submodule R M) (N' : Submodule R N) (M'' : Submodule R M')
(N'' : Submodule R N') (e : (M' ⧸ M'') ≃ₗ[R] N' ⧸ N''),
L = (e.graph.comap <| M''.mkQ.prodMap N''.mkQ).map (M'.subtype.prodMap N'.subtype) := by
let M' := L.map (LinearMap.fst ..)
let N' := L.map (LinearMap.snd ..)
let P : L →ₗ[R] M' := (LinearMap.fst ..).submoduleMap L
let Q : L →ₗ[R] N' := (LinearMap.snd ..).submoduleMap L
let L' : Submodule R (M' × N') := LinearMap.range (P.prod Q)
have hL₁' : Surjective (Prod.fst ∘ L'.subtype) := by
simp only [← coe_fst (R := R), ← coe_comp, ← range_eq_top, LinearMap.range_comp, range_subtype]
simpa only [L', ← LinearMap.range_comp, fst_prod, range_eq_top] using
(LinearMap.fst ..).submoduleMap_surjective L
have hL₂' : Surjective (Prod.snd ∘ L'.subtype) := by
simp only [← coe_snd (R := R), ← coe_comp, ← range_eq_top, LinearMap.range_comp, range_subtype]
simpa only [L', ← LinearMap.range_comp, snd_prod, range_eq_top] using
(LinearMap.snd ..).submoduleMap_surjective L
obtain ⟨e, he⟩ := goursat_surjective hL₁' hL₂'
use M', N', L'.goursatFst, L'.goursatSnd, e
rw [← he]
simp only [LinearMap.range_comp, Submodule.range_subtype, L']
rw [comap_map_eq_self]
· ext ⟨m, n⟩
constructor
· intro hmn
simp only [mem_map, LinearMap.mem_range, prod_apply, Subtype.exists, Prod.exists, coe_prodMap,
coe_subtype, Prod.map_apply, Prod.mk.injEq, exists_and_right, exists_eq_right_right,
exists_eq_right, M', N', fst_apply, snd_apply]
exact ⟨⟨n, hmn⟩, ⟨m, hmn⟩, ⟨m, n, hmn, rfl⟩⟩
· simp only [mem_map, LinearMap.mem_range, prod_apply, Subtype.exists, Prod.exists,
coe_prodMap, coe_subtype, Prod.map_apply, Prod.mk.injEq, exists_and_right,
exists_eq_right_right, exists_eq_right, forall_exists_index, Pi.prod]
rintro hm hn m₁ n₁ hm₁n₁ ⟨hP, hQ⟩
simp only [Subtype.ext_iff] at hP hQ
rwa [← hP, ← hQ]
· convert goursatFst_prod_goursatSnd_le (range <| P.prod Q)
ext ⟨m, n⟩
simp_rw [mem_ker, coe_prodMap, Prod.map_apply, Submodule.mem_prod, Prod.zero_eq_mk,
Prod.ext_iff, ← mem_ker, ker_mkQ] | lemma | LinearAlgebra | [
"Mathlib.GroupTheory.Goursat",
"Mathlib.LinearAlgebra.Prod",
"Mathlib.LinearAlgebra.Quotient.Basic"
] | Mathlib/LinearAlgebra/Goursat.lean | goursat | **Goursat's lemma** for an arbitrary submodule of a product.
If `L` is a submodule of `M × N`, then there exist submodules `M'' ≤ M' ≤ M` and `N'' ≤ N' ≤ N` such
that `L ≤ M' × N'`, and `L` is (the image in `M × N` of) the preimage of the graph of an `R`-linear
isomorphism `M' ⧸ M'' ≃ N' ⧸ N''`. |
@[mk_iff]
StrongRankCondition : Prop where
/-- Any injective linear map from `Rⁿ` to `Rᵐ` guarantees `n ≤ m`. -/
le_of_fin_injective : ∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Injective f → n ≤ m | class | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | StrongRankCondition | We say that `R` satisfies the strong rank condition if `(Fin n → R) →ₗ[R] (Fin m → R)` injective
implies `n ≤ m`. |
le_of_fin_injective [StrongRankCondition R] {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R) :
Injective f → n ≤ m :=
StrongRankCondition.le_of_fin_injective f | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | le_of_fin_injective | null |
strongRankCondition_iff_succ :
StrongRankCondition R ↔
∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Function.Injective f := by
refine ⟨fun h n => fun f hf => ?_, fun h => ⟨@fun n m f hf => ?_⟩⟩
· letI : StrongRankCondition R := h
exact Nat.not_succ_le_self n (le_of_fin_injective R f hf)
· by_contra H
exact
h m (f.comp (Function.ExtendByZero.linearMap R (Fin.castLE (not_le.1 H))))
(hf.comp (Function.extend_injective (Fin.strictMono_castLE _).injective _)) | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | strongRankCondition_iff_succ | A ring satisfies the strong rank condition if and only if, for all `n : ℕ`, any linear map
`(Fin (n + 1) → R) →ₗ[R] (Fin n → R)` is not injective. |
RankCondition : Prop where
/-- Any surjective linear map from `Rⁿ` to `Rᵐ` guarantees `m ≤ n`. -/
le_of_fin_surjective : ∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Surjective f → m ≤ n | class | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | RankCondition | Any nontrivial ring satisfying Orzech property also satisfies strong rank condition. -/
instance (priority := 100) strongRankCondition_of_orzechProperty
[Nontrivial R] [OrzechProperty R] : StrongRankCondition R := by
refine (strongRankCondition_iff_succ R).2 fun n i hi ↦ ?_
let f : (Fin (n + 1) → R) →ₗ[R] Fin n → R := {
toFun := fun x ↦ x ∘ Fin.castSucc
map_add' := fun _ _ ↦ rfl
map_smul' := fun _ _ ↦ rfl
}
have h : (0 : Fin (n + 1) → R) = update (0 : Fin (n + 1) → R) (Fin.last n) 1 := by
apply OrzechProperty.injective_of_surjective_of_injective i f hi
(Fin.castSucc_injective _).surjective_comp_right
ext m
simp [f]
simpa using congr_fun h (Fin.last n)
theorem card_le_of_injective [StrongRankCondition R] {α β : Type*} [Fintype α] [Fintype β]
(f : (α → R) →ₗ[R] β → R) (i : Injective f) : Fintype.card α ≤ Fintype.card β := by
let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
exact
le_of_fin_injective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
(((LinearEquiv.symm Q).injective.comp i).comp (LinearEquiv.injective P))
theorem card_le_of_injective' [StrongRankCondition R] {α β : Type*} [Fintype α] [Fintype β]
(f : (α →₀ R) →ₗ[R] β →₀ R) (i : Injective f) : Fintype.card α ≤ Fintype.card β := by
let P := Finsupp.linearEquivFunOnFinite R R β
let Q := (Finsupp.linearEquivFunOnFinite R R α).symm
exact
card_le_of_injective R ((P.toLinearMap.comp f).comp Q.toLinearMap)
((P.injective.comp i).comp Q.injective)
/-- We say that `R` satisfies the rank condition if `(Fin n → R) →ₗ[R] (Fin m → R)` surjective
implies `m ≤ n`. |
le_of_fin_surjective [RankCondition R] {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R) :
Surjective f → m ≤ n :=
RankCondition.le_of_fin_surjective f | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | le_of_fin_surjective | null |
card_le_of_surjective [RankCondition R] {α β : Type*} [Fintype α] [Fintype β]
(f : (α → R) →ₗ[R] β → R) (i : Surjective f) : Fintype.card β ≤ Fintype.card α := by
let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
exact
le_of_fin_surjective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
(((LinearEquiv.symm Q).surjective.comp i).comp (LinearEquiv.surjective P)) | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | card_le_of_surjective | null |
card_le_of_surjective' [RankCondition R] {α β : Type*} [Fintype α] [Fintype β]
(f : (α →₀ R) →ₗ[R] β →₀ R) (i : Surjective f) : Fintype.card β ≤ Fintype.card α := by
let P := Finsupp.linearEquivFunOnFinite R R β
let Q := (Finsupp.linearEquivFunOnFinite R R α).symm
exact
card_le_of_surjective R ((P.toLinearMap.comp f).comp Q.toLinearMap)
((P.surjective.comp i).comp Q.surjective) | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | card_le_of_surjective' | null |
Module.Finite.exists_nat_not_surjective [RankCondition R] (M) [AddCommMonoid M] [Module R M]
[Module.Finite R M] : ∃ n : ℕ, ∀ f : M →ₗ[R] (Fin n → R), ¬Surjective f :=
have ⟨n, f, hf⟩ := Module.Finite.exists_fin' R M
⟨n + 1, fun g hg ↦ by simpa using le_of_fin_surjective R (g ∘ₗ f) (hg.comp hf)⟩ | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | Module.Finite.exists_nat_not_surjective | null |
InvariantBasisNumber : Prop where
/-- Any linear equiv between `Rⁿ` and `Rᵐ` guarantees `m = n`. -/
eq_of_fin_equiv : ∀ {n m : ℕ}, ((Fin n → R) ≃ₗ[R] Fin m → R) → n = m | class | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | InvariantBasisNumber | By the universal property for free modules, any surjective map `(Fin n → R) →ₗ[R] (Fin m → R)`
has an injective splitting `(Fin m → R) →ₗ[R] (Fin n → R)`
from which the strong rank condition gives the necessary inequality for the rank condition.
-/
instance (priority := 100) rankCondition_of_strongRankCondition [StrongRankCondition R] :
RankCondition R where
le_of_fin_surjective f s :=
le_of_fin_injective R _ (f.splittingOfFunOnFintypeSurjective_injective s)
/-- We say that `R` has the invariant basis number property if `(Fin n → R) ≃ₗ[R] (Fin m → R)`
implies `n = m`. This gives rise to a well-defined notion of rank of a finitely generated free
module. |
eq_of_fin_equiv {n m : ℕ} : ((Fin n → R) ≃ₗ[R] Fin m → R) → n = m :=
InvariantBasisNumber.eq_of_fin_equiv | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | eq_of_fin_equiv | null |
card_eq_of_linearEquiv {α β : Type*} [Fintype α] [Fintype β] (f : (α → R) ≃ₗ[R] β → R) :
Fintype.card α = Fintype.card β :=
eq_of_fin_equiv R
((LinearEquiv.funCongrLeft R R (Fintype.equivFin α)).trans f ≪≫ₗ
(LinearEquiv.funCongrLeft R R (Fintype.equivFin β)).symm) | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | card_eq_of_linearEquiv | null |
nontrivial_of_invariantBasisNumber : Nontrivial R := by
by_contra! h
refine zero_ne_one (eq_of_fin_equiv R ?_)
haveI : Subsingleton (Fin 1 → R) :=
Subsingleton.intro fun a b => funext fun x => Subsingleton.elim _ _
exact
{ toFun := 0
invFun := 0
map_add' := by simp
map_smul' := by simp
left_inv := fun _ => by simp [eq_iff_true_of_subsingleton]
right_inv := fun _ => by simp [eq_iff_true_of_subsingleton] } | theorem | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | nontrivial_of_invariantBasisNumber | null |
private induced_map (I : Ideal R) (e : (ι → R) →ₗ[R] ι' → R) :
(ι → R) ⧸ Ideal.pi (fun _ ↦ I) → (ι' → R) ⧸ Ideal.pi fun _ ↦ I := fun x =>
Quotient.liftOn' x (fun y => Ideal.Quotient.mk _ (e y))
(by
refine fun a b hab => Ideal.Quotient.eq.2 fun h => ?_
rw [Submodule.quotientRel_def] at hab
rw [← LinearMap.map_sub]
exact Ideal.map_pi _ _ hab e h) | def | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | induced_map | Any nontrivial Noetherian ring satisfies the strong rank condition,
since it satisfies Orzech property. -/
instance (priority := 100) IsNoetherianRing.strongRankCondition : StrongRankCondition R :=
inferInstance
end
/-!
We want to show that nontrivial commutative rings have invariant basis number. The idea is to
take a maximal ideal `I` of `R` and use an isomorphism `R^n ≃ R^m` of `R` modules to produce an
isomorphism `(R/I)^n ≃ (R/I)^m` of `R/I`-modules, which will imply `n = m` since `R/I` is a field
and we know that fields have invariant basis number.
We construct the isomorphism in two steps:
1. We construct the ring `R^n/I^n`, show that it is an `R/I`-module and show that there is an
isomorphism of `R/I`-modules `R^n/I^n ≃ (R/I)^n`. This isomorphism is called
`Ideal.piQuotEquiv` and is located in the file `RingTheory/Ideals.lean`.
2. We construct an isomorphism of `R/I`-modules `R^n/I^n ≃ R^m/I^m` using the isomorphism
`R^n ≃ R^m`.
-/
section
variable {R : Type u} [CommRing R] (I : Ideal R) {ι : Type v} [Fintype ι] {ι' : Type w}
/-- An `R`-linear map `R^n → R^m` induces a function `R^n/I^n → R^m/I^m`. |
private inducedEquiv [Fintype ι'] (I : Ideal R) (e : (ι → R) ≃ₗ[R] ι' → R) :
((ι → R) ⧸ Ideal.pi fun _ ↦ I) ≃ₗ[R ⧸ I] (ι' → R) ⧸ Ideal.pi fun _ ↦ I where
toFun := induced_map I e
invFun := induced_map I e.symm
map_add' := by rintro ⟨a⟩ ⟨b⟩; exact congr_arg _ (map_add ..)
map_smul' := by rintro ⟨a⟩ ⟨b⟩; exact congr_arg _ (map_smul ..)
left_inv := by rintro ⟨a⟩; exact congr_arg _ (e.left_inv ..)
right_inv := by rintro ⟨a⟩; exact congr_arg _ (e.right_inv ..) | def | LinearAlgebra | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Orzech",
"Mathlib.RingTheory.OrzechProperty",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | inducedEquiv | An isomorphism of `R`-modules `R^n ≃ R^m` induces an isomorphism of `R/I`-modules
`R^n/I^n ≃ R^m/I^m`. |
noncomputable quotKerEquivRange : (M ⧸ LinearMap.ker f) ≃ₗ[R] LinearMap.range f :=
(LinearEquiv.ofInjective ((LinearMap.ker f).liftQ f <| le_rfl) <|
ker_eq_bot.mp <| Submodule.ker_liftQ_eq_bot _ _ _ (le_refl (LinearMap.ker f))).trans
(LinearEquiv.ofEq _ _ <| Submodule.range_liftQ _ _ _) | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | quotKerEquivRange | The **first isomorphism law for modules**. The quotient of `M` by the kernel of `f` is linearly
equivalent to the range of `f`. |
noncomputable quotKerEquivOfSurjective (f : M →ₗ[R] M₂) (hf : Function.Surjective f) :
(M ⧸ LinearMap.ker f) ≃ₗ[R] M₂ :=
f.quotKerEquivRange.trans <| .ofTop (LinearMap.range f) <| range_eq_top.2 hf
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | quotKerEquivOfSurjective | The **first isomorphism theorem for surjective linear maps**. |
quotKerEquivRange_apply_mk (x : M) :
(f.quotKerEquivRange (Submodule.Quotient.mk x) : M₂) = f x :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | quotKerEquivRange_apply_mk | null |
quotKerEquivOfSurjective_apply_mk (hf : Function.Surjective f) (x : M) :
(f.quotKerEquivOfSurjective hf (Submodule.Quotient.mk x) : M₂) = f x :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | quotKerEquivOfSurjective_apply_mk | null |
quotKerEquivRange_symm_apply_image (x : M) (h : f x ∈ LinearMap.range f) :
f.quotKerEquivRange.symm ⟨f x, h⟩ = (LinearMap.ker f).mkQ x :=
f.quotKerEquivRange.symm_apply_apply ((LinearMap.ker f).mkQ x) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | quotKerEquivRange_symm_apply_image | null |
subToSupQuotient (p p' : Submodule R M) :
{ x // x ∈ p } →ₗ[R] { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p' :=
(comap (p ⊔ p').subtype p').mkQ.comp (Submodule.inclusion le_sup_left) | abbrev | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | subToSupQuotient | Linear map from `p` to `p+p'/p'` where `p p'` are submodules of `R` |
comap_leq_ker_subToSupQuotient (p p' : Submodule R M) :
comap (Submodule.subtype p) (p ⊓ p') ≤ ker (subToSupQuotient p p') := by
rw [LinearMap.ker_comp, Submodule.inclusion, comap_codRestrict, ker_mkQ, map_comap_subtype]
exact comap_mono (inf_le_inf_right _ le_sup_left) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.LinearAlgebra.Quotient.Card"
] | Mathlib/LinearAlgebra/Isomorphisms.lean | comap_leq_ker_subToSupQuotient | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.